From e3b1d6e5d2379977de477a2614f960d4f19e6dea Mon Sep 17 00:00:00 2001
From: Zeger-Jan van de Weg <git@zjvandeweg.nl>
Date: Wed, 3 Jun 2020 14:45:14 +0200
Subject: [PATCH 1/2] lines.Send() takes SenderOpts for grouping options

The lines.Send() allows for a command to be passed in, so the output can
be split based on a delimiter. To control what would be send to the
client this package will be extended to allow for pagination and limits.

The lines.Send() function than would read from the passed in io.Reader,
and write to the sink passed as `lines.Sender`, and the logic that
alters the execution between these would be send as part of the
SenderOpts struct.

A small test was added, mostly to force compilation of the package when
running `go test`, as well as unit test coverage.
---
 internal/helper/lines/send.go               | 29 +++++++++++++--------
 internal/helper/lines/send_test.go          | 25 ++++++++++++++++++
 internal/service/ref/refs.go                |  8 +++---
 internal/service/repository/search_files.go |  2 +-
 4 files changed, 49 insertions(+), 15 deletions(-)
 create mode 100644 internal/helper/lines/send_test.go

diff --git a/internal/helper/lines/send.go b/internal/helper/lines/send.go
index 4414344d0d..d46672c18e 100644
--- a/internal/helper/lines/send.go
+++ b/internal/helper/lines/send.go
@@ -6,6 +6,10 @@ import (
 	"io"
 )
 
+type SenderOpts struct {
+	Delimiter []byte
+}
+
 // ItemsPerMessage establishes the threshold to flush the buffer when using the
 // `Send` function. It's a variable instead of a constant to make it possible to
 // override in tests.
@@ -15,9 +19,9 @@ var ItemsPerMessage = 20
 type Sender func([][]byte) error
 
 type writer struct {
-	sender Sender
-	lines  [][]byte
-	delim  []byte
+	sender  Sender
+	lines   [][]byte
+	options SenderOpts
 }
 
 // CopyAndAppend adds a newly allocated copy of `e` to the `s` slice. Useful to
@@ -67,14 +71,14 @@ func (w *writer) consume(r io.Reader) error {
 
 		for {
 			// delim can be multiple bytes, so we read till the end byte of it ...
-			chunk, err := buf.ReadBytes(w.delim[len(w.delim)-1])
+			chunk, err := buf.ReadBytes(w.delimiter()[len(w.delimiter())-1])
 			if err != nil && err != io.EOF {
 				return err
 			}
 
 			line = append(line, chunk...)
 			// ... then we check if the last bytes of line are the same as delim
-			if bytes.HasSuffix(line, w.delim) {
+			if bytes.HasSuffix(line, w.delimiter()) {
 				break
 			}
 
@@ -84,7 +88,7 @@ func (w *writer) consume(r io.Reader) error {
 			}
 		}
 
-		line = bytes.TrimRight(line, string(w.delim))
+		line = bytes.TrimRight(line, string(w.delimiter()))
 		if len(line) == 0 {
 			break
 		}
@@ -97,12 +101,15 @@ func (w *writer) consume(r io.Reader) error {
 	return w.flush()
 }
 
-// Send reads output from `r`, splits it at `delim`, then handles the buffered lines using `sender`.
-func Send(r io.Reader, sender Sender, delim []byte) error {
-	if len(delim) == 0 {
-		delim = []byte{'\n'}
+func (w *writer) delimiter() []byte { return w.options.Delimiter }
+
+// Send reads output from `r`, splits it at `opts.Delimiter``, then handles the
+// buffered lines using `sender`.
+func Send(r io.Reader, sender Sender, opts SenderOpts) error {
+	if len(opts.Delimiter) == 0 {
+		opts.Delimiter = []byte{'\n'}
 	}
 
-	writer := &writer{sender: sender, delim: delim}
+	writer := &writer{sender: sender, options: opts}
 	return writer.consume(r)
 }
diff --git a/internal/helper/lines/send_test.go b/internal/helper/lines/send_test.go
new file mode 100644
index 0000000000..8e880fdea5
--- /dev/null
+++ b/internal/helper/lines/send_test.go
@@ -0,0 +1,25 @@
+package lines
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestLinesSend(t *testing.T) {
+	reader := bytes.NewBufferString("mepmep foo bar")
+
+	var out [][]byte
+	sender := func(in [][]byte) error { out = in; return nil }
+	err := Send(reader, sender, SenderOpts{Delimiter: []byte(" ")})
+	require.NoError(t, err)
+
+	expected := [][]byte{
+		[]byte("mepmep"),
+		[]byte("foo"),
+		[]byte("bar"),
+	}
+
+	require.Equal(t, expected, out)
+}
diff --git a/internal/service/ref/refs.go b/internal/service/ref/refs.go
index c4a8e831f5..381236c5ca 100644
--- a/internal/service/ref/refs.go
+++ b/internal/service/ref/refs.go
@@ -32,8 +32,10 @@ var (
 )
 
 type findRefsOpts struct {
-	cmdArgs []git.Option
-	delim   []byte
+	cmdArgs   []git.Option
+	delim     []byte
+	pageToken string
+	limit     uint32
 }
 
 func findRefs(ctx context.Context, writer lines.Sender, repo *gitalypb.Repository, patterns []string, opts *findRefsOpts) error {
@@ -54,7 +56,7 @@ func findRefs(ctx context.Context, writer lines.Sender, repo *gitalypb.Repositor
 		return err
 	}
 
-	if err := lines.Send(cmd, writer, opts.delim); err != nil {
+	if err := lines.Send(cmd, writer, lines.SenderOpts{Delimiter: opts.delim}); err != nil {
 		return err
 	}
 
diff --git a/internal/service/repository/search_files.go b/internal/service/repository/search_files.go
index fac6ecbe0e..26503f006e 100644
--- a/internal/service/repository/search_files.go
+++ b/internal/service/repository/search_files.go
@@ -123,7 +123,7 @@ func (s *server) SearchFilesByName(req *gitalypb.SearchFilesByNameRequest, strea
 		return stream.Send(&gitalypb.SearchFilesByNameResponse{Files: objs})
 	}
 
-	return lines.Send(cmd, lr, []byte{'\n'})
+	return lines.Send(cmd, lr, lines.SenderOpts{Delimiter: []byte{'\n'}})
 }
 
 type searchFilesRequest interface {
-- 
GitLab


From 7ed81f1389da5dc41c2cad0508ea335863425852 Mon Sep 17 00:00:00 2001
From: Zeger-Jan van de Weg <git@zjvandeweg.nl>
Date: Wed, 3 Jun 2020 19:01:11 +0200
Subject: [PATCH 2/2] Allow pagination for FindAllLocalBranches

Pagination has always been ad hoc within Gitaly, and there was no
convergence to a standard. This change creates a structure around this,
which an implementation for one RPC to try it.

The structure uses a page token, as proposed in:
https://gitlab.com/gitlab-org/gitaly/-/issues/2704#note_349733942.
This allows a generic field to hold what's usually a numeric `offset`
field. Where `offset` can be unstable over a series of requests due to
race conditions, the page token could prevent that.

The change does alter the implementation for `lines.Send()` a little,
which create a situation where for other RPCs there's been slight
normalization on their input to `lines.Send()` to make this change
backward as well as forward compatible.

Helps with: https://gitlab.com/gitlab-org/gitlab-foss/-/issues/48097#note_354316835
Part of: https://gitlab.com/gitlab-org/gitaly/-/issues/2704
---
 .../unreleased/zj-pagination-lines-sender.yml |   5 +
 internal/helper/lines/send.go                 |  38 ++-
 internal/helper/lines/send_test.go            |  57 ++++-
 internal/service/ref/refs.go                  |  51 +++-
 internal/service/ref/refs_test.go             |  63 +++++
 internal/service/ref/remote_branches.go       |   5 +-
 internal/service/ref/testhelper_test.go       |   4 +
 internal/service/repository/search_files.go   |   3 +-
 proto/go/gitalypb/ref.pb.go                   | 240 +++++++++---------
 proto/go/gitalypb/shared.pb.go                | 164 ++++++++----
 proto/ref.proto                               |   5 +
 proto/shared.proto                            |  16 ++
 ruby/proto/gitaly/ref_pb.rb                   |   1 +
 ruby/proto/gitaly/shared_pb.rb                |   5 +
 14 files changed, 463 insertions(+), 194 deletions(-)
 create mode 100644 changelogs/unreleased/zj-pagination-lines-sender.yml

diff --git a/changelogs/unreleased/zj-pagination-lines-sender.yml b/changelogs/unreleased/zj-pagination-lines-sender.yml
new file mode 100644
index 0000000000..0fc2b7c0be
--- /dev/null
+++ b/changelogs/unreleased/zj-pagination-lines-sender.yml
@@ -0,0 +1,5 @@
+---
+title: Allow pagination for FindAllLocalBranches
+merge_request: 2251
+author:
+type: added
diff --git a/internal/helper/lines/send.go b/internal/helper/lines/send.go
index d46672c18e..65fd2c0199 100644
--- a/internal/helper/lines/send.go
+++ b/internal/helper/lines/send.go
@@ -6,8 +6,22 @@ import (
 	"io"
 )
 
+// SenderOpts contains fields that Send() uses to determine what is considered
+// a line, and how to handle pagination. That is, how many lines to skip, before
+// a line gets fed into the Sender.
 type SenderOpts struct {
+	// Delimiter is the separator used to split the sender's output into
+	// lines. Defaults to "\n".
 	Delimiter []byte
+	// Limit is the upper limit of how many lines will be sent. The zero
+	// value will cause no lines to be sent.
+	Limit int
+	// IsPageToken allows control over which results are sent as part of the
+	// response. When IsPageToken evaluates to true for the first time,
+	// results will start to be sent as part of the response. This function
+	// will	be called with an empty slice previous to sending the first line
+	// in order to allow sending everything right from the beginning.
+	IsPageToken func([]byte) bool
 }
 
 // ItemsPerMessage establishes the threshold to flush the buffer when using the
@@ -66,7 +80,11 @@ func (w *writer) addLine(p []byte) error {
 func (w *writer) consume(r io.Reader) error {
 	buf := bufio.NewReader(r)
 
-	for finished := false; !finished; {
+	// As `IsPageToken` will instruct us to send the _next_ line only, we
+	// need to call it before the first iteration to allow for the case
+	// where we want to send right from the beginning.
+	pastPageToken := w.options.IsPageToken([]byte{})
+	for i := 0; i < w.options.Limit; {
 		var line []byte
 
 		for {
@@ -83,16 +101,24 @@ func (w *writer) consume(r io.Reader) error {
 			}
 
 			if err == io.EOF {
-				finished = true
+				i = w.options.Limit // Implicit exit clause for the loop
 				break
 			}
 		}
 
-		line = bytes.TrimRight(line, string(w.delimiter()))
+		line = bytes.TrimSuffix(line, w.delimiter())
 		if len(line) == 0 {
 			break
 		}
 
+		// If a page token is given, we need to skip all lines until we've found it.
+		// All remaining lines will then be sent until we reach the pagination limit.
+		if !pastPageToken {
+			pastPageToken = w.options.IsPageToken(line)
+			continue
+		}
+		i++ // Only increment the counter if the result wasn't skipped
+
 		if err := w.addLine(line); err != nil {
 			return err
 		}
@@ -103,13 +129,17 @@ func (w *writer) consume(r io.Reader) error {
 
 func (w *writer) delimiter() []byte { return w.options.Delimiter }
 
-// Send reads output from `r`, splits it at `opts.Delimiter``, then handles the
+// Send reads output from `r`, splits it at `opts.Delimiter`, then handles the
 // buffered lines using `sender`.
 func Send(r io.Reader, sender Sender, opts SenderOpts) error {
 	if len(opts.Delimiter) == 0 {
 		opts.Delimiter = []byte{'\n'}
 	}
 
+	if opts.IsPageToken == nil {
+		opts.IsPageToken = func(_ []byte) bool { return true }
+	}
+
 	writer := &writer{sender: sender, options: opts}
 	return writer.consume(r)
 }
diff --git a/internal/helper/lines/send_test.go b/internal/helper/lines/send_test.go
index 8e880fdea5..523d822ac2 100644
--- a/internal/helper/lines/send_test.go
+++ b/internal/helper/lines/send_test.go
@@ -8,18 +8,59 @@ import (
 )
 
 func TestLinesSend(t *testing.T) {
-	reader := bytes.NewBufferString("mepmep foo bar")
-
-	var out [][]byte
-	sender := func(in [][]byte) error { out = in; return nil }
-	err := Send(reader, sender, SenderOpts{Delimiter: []byte(" ")})
-	require.NoError(t, err)
-
 	expected := [][]byte{
 		[]byte("mepmep"),
 		[]byte("foo"),
 		[]byte("bar"),
 	}
 
-	require.Equal(t, expected, out)
+	tcs := []struct {
+		desc        string
+		limit       int
+		isPageToken func([]byte) bool
+		output      [][]byte
+	}{
+		{
+			desc:   "high limit",
+			limit:  100,
+			output: expected,
+		},
+		{
+			desc:   "limit is 0",
+			limit:  0,
+			output: [][]byte(nil),
+		},
+		{
+			desc:   "limit 2",
+			limit:  2,
+			output: expected[0:2],
+		},
+		{
+			desc:        "skip lines",
+			limit:       100,
+			isPageToken: func(line []byte) bool { return bytes.HasPrefix(line, expected[0]) },
+			output:      expected[1:3],
+		},
+		{
+			desc:        "skip no lines",
+			limit:       100,
+			isPageToken: func(_ []byte) bool { return true },
+			output:      expected,
+		},
+	}
+
+	for _, tc := range tcs {
+		t.Run(tc.desc, func(t *testing.T) {
+			reader := bytes.NewBufferString("mepmep\nfoo\nbar")
+			var out [][]byte
+			sender := func(in [][]byte) error { out = in; return nil }
+
+			err := Send(reader, sender, SenderOpts{
+				Limit:       tc.limit,
+				IsPageToken: tc.isPageToken,
+			})
+			require.NoError(t, err)
+			require.Equal(t, tc.output, out)
+		})
+	}
 }
diff --git a/internal/service/ref/refs.go b/internal/service/ref/refs.go
index 381236c5ca..f15f167961 100644
--- a/internal/service/ref/refs.go
+++ b/internal/service/ref/refs.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"math"
 	"strings"
 
 	"github.com/golang/protobuf/proto"
@@ -32,10 +33,9 @@ var (
 )
 
 type findRefsOpts struct {
-	cmdArgs   []git.Option
-	delim     []byte
-	pageToken string
-	limit     uint32
+	cmdArgs []git.Option
+	delim   []byte
+	lines.SenderOpts
 }
 
 func findRefs(ctx context.Context, writer lines.Sender, repo *gitalypb.Repository, patterns []string, opts *findRefsOpts) error {
@@ -56,7 +56,11 @@ func findRefs(ctx context.Context, writer lines.Sender, repo *gitalypb.Repositor
 		return err
 	}
 
-	if err := lines.Send(cmd, writer, lines.SenderOpts{Delimiter: opts.delim}); err != nil {
+	if err := lines.Send(cmd, writer, lines.SenderOpts{
+		IsPageToken: opts.IsPageToken,
+		Delimiter:   opts.delim,
+		Limit:       int(opts.Limit),
+	}); err != nil {
 		return err
 	}
 
@@ -301,12 +305,11 @@ func findLocalBranches(in *gitalypb.FindLocalBranchesRequest, stream gitalypb.Re
 	}
 
 	writer := newFindLocalBranchesWriter(stream, c)
-	opts := &findRefsOpts{
-		cmdArgs: []git.Option{
-			// %00 inserts the null character into the output (see for-each-ref docs)
-			git.Flag{"--format=" + strings.Join(localBranchFormatFields, "%00")},
-			git.Flag{"--sort=" + parseSortKey(in.GetSortBy())},
-		},
+	opts := paginationParamsToOpts(in.GetPaginationParams())
+	opts.cmdArgs = []git.Option{
+		// %00 inserts the null character into the output (see for-each-ref docs)
+		git.Flag{"--format=" + strings.Join(localBranchFormatFields, "%00")},
+		git.Flag{"--sort=" + parseSortKey(in.GetSortBy())},
 	}
 
 	return findRefs(ctx, writer, in.Repository, []string{"refs/heads"}, opts)
@@ -351,9 +354,9 @@ func findAllBranches(in *gitalypb.FindAllBranchesRequest, stream gitalypb.RefSer
 		return err
 	}
 
-	opts := &findRefsOpts{
-		cmdArgs: args,
-	}
+	opts := paginationParamsToOpts(nil)
+	opts.cmdArgs = args
+
 	writer := newFindAllBranchesWriter(stream, c)
 
 	return findRefs(ctx, writer, in.Repository, patterns, opts)
@@ -458,3 +461,23 @@ func validateFindTagRequest(in *gitalypb.FindTagRequest) error {
 	}
 	return nil
 }
+
+func paginationParamsToOpts(p *gitalypb.PaginationParameter) *findRefsOpts {
+	opts := &findRefsOpts{}
+	opts.IsPageToken = func(_ []byte) bool { return true }
+	opts.Limit = math.MaxInt32
+
+	if p == nil {
+		return opts
+	}
+
+	if p.GetLimit() >= 0 {
+		opts.Limit = int(p.GetLimit())
+	}
+
+	if p.GetPageToken() != "" {
+		opts.IsPageToken = func(l []byte) bool { return bytes.Compare(l, []byte(p.GetPageToken())) >= 0 }
+	}
+
+	return opts
+}
diff --git a/internal/service/ref/refs_test.go b/internal/service/ref/refs_test.go
index a026fbd410..c3dff3f37b 100644
--- a/internal/service/ref/refs_test.go
+++ b/internal/service/ref/refs_test.go
@@ -932,6 +932,69 @@ func TestSuccessfulFindLocalBranches(t *testing.T) {
 	}
 }
 
+func TestFindLocalBranchesPagination(t *testing.T) {
+	stop, serverSocketPath := runRefServiceServer(t)
+	defer stop()
+
+	client, conn := newRefServiceClient(t, serverSocketPath)
+	defer conn.Close()
+
+	testRepo, _, cleanupFn := testhelper.NewTestRepo(t)
+	defer cleanupFn()
+
+	ctx, cancel := testhelper.Context()
+	defer cancel()
+
+	limit := 1
+	rpcRequest := &gitalypb.FindLocalBranchesRequest{
+		Repository: testRepo,
+		PaginationParams: &gitalypb.PaginationParameter{
+			Limit:     int32(limit),
+			PageToken: "refs/heads/gitaly/squash-test",
+		},
+	}
+	c, err := client.FindLocalBranches(ctx, rpcRequest)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var branches []*gitalypb.FindLocalBranchResponse
+	for {
+		r, err := c.Recv()
+		if err == io.EOF {
+			break
+		}
+		require.NoError(t, err)
+		if err != nil {
+			t.Fatal(err)
+		}
+		branches = append(branches, r.GetBranches()...)
+	}
+
+	require.Len(t, branches, limit)
+
+	expectedBranch := "refs/heads/improve/awesome"
+	target := localBranches[expectedBranch]
+
+	branch := &gitalypb.FindLocalBranchResponse{
+		Name:          []byte(expectedBranch),
+		CommitId:      target.Id,
+		CommitSubject: target.Subject,
+		CommitAuthor: &gitalypb.FindLocalBranchCommitAuthor{
+			Name:  target.Author.Name,
+			Email: target.Author.Email,
+			Date:  target.Author.Date,
+		},
+		CommitCommitter: &gitalypb.FindLocalBranchCommitAuthor{
+			Name:  target.Committer.Name,
+			Email: target.Committer.Email,
+			Date:  target.Committer.Date,
+		},
+		Commit: target,
+	}
+	assertContainsLocalBranch(t, branches, branch)
+}
+
 // Test that `s` contains the elements in `relativeOrder` in that order
 // (relative to each other)
 func isOrderedSubset(subset, set []string) bool {
diff --git a/internal/service/ref/remote_branches.go b/internal/service/ref/remote_branches.go
index a9712cc7c7..f82e9b3f86 100644
--- a/internal/service/ref/remote_branches.go
+++ b/internal/service/ref/remote_branches.go
@@ -35,9 +35,8 @@ func findAllRemoteBranches(req *gitalypb.FindAllRemoteBranchesRequest, stream gi
 		return err
 	}
 
-	opts := &findRefsOpts{
-		cmdArgs: args,
-	}
+	opts := paginationParamsToOpts(nil)
+	opts.cmdArgs = args
 	writer := newFindAllRemoteBranchesWriter(stream, c)
 
 	return findRefs(ctx, writer, req.GetRepository(), patterns, opts)
diff --git a/internal/service/ref/testhelper_test.go b/internal/service/ref/testhelper_test.go
index cc84e57f83..f40730edef 100644
--- a/internal/service/ref/testhelper_test.go
+++ b/internal/service/ref/testhelper_test.go
@@ -116,6 +116,8 @@ func newRefServiceClient(t *testing.T, serverSocketPath string) (gitalypb.RefSer
 }
 
 func assertContainsLocalBranch(t *testing.T, branches []*gitalypb.FindLocalBranchResponse, branch *gitalypb.FindLocalBranchResponse) {
+	t.Helper()
+
 	for _, b := range branches {
 		if bytes.Equal(branch.Name, b.Name) {
 			if !testhelper.FindLocalBranchResponsesEqual(branch, b) {
@@ -129,6 +131,8 @@ func assertContainsLocalBranch(t *testing.T, branches []*gitalypb.FindLocalBranc
 }
 
 func assertContainsBranch(t *testing.T, branches []*gitalypb.FindAllBranchesResponse_Branch, branch *gitalypb.FindAllBranchesResponse_Branch) {
+	t.Helper()
+
 	var branchNames [][]byte
 
 	for _, b := range branches {
diff --git a/internal/service/repository/search_files.go b/internal/service/repository/search_files.go
index 26503f006e..5a19550d3a 100644
--- a/internal/service/repository/search_files.go
+++ b/internal/service/repository/search_files.go
@@ -5,6 +5,7 @@ import (
 	"bytes"
 	"errors"
 	"io"
+	"math"
 
 	"gitlab.com/gitlab-org/gitaly/internal/command"
 	"gitlab.com/gitlab-org/gitaly/internal/git"
@@ -123,7 +124,7 @@ func (s *server) SearchFilesByName(req *gitalypb.SearchFilesByNameRequest, strea
 		return stream.Send(&gitalypb.SearchFilesByNameResponse{Files: objs})
 	}
 
-	return lines.Send(cmd, lr, lines.SenderOpts{Delimiter: []byte{'\n'}})
+	return lines.Send(cmd, lr, lines.SenderOpts{Delimiter: []byte{'\n'}, Limit: math.MaxInt32})
 }
 
 type searchFilesRequest interface {
diff --git a/proto/go/gitalypb/ref.pb.go b/proto/go/gitalypb/ref.pb.go
index dbcfe68f60..940c3d9a97 100644
--- a/proto/go/gitalypb/ref.pb.go
+++ b/proto/go/gitalypb/ref.pb.go
@@ -512,11 +512,16 @@ func (m *FindRefNameResponse) GetName() []byte {
 }
 
 type FindLocalBranchesRequest struct {
-	Repository           *Repository                     `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
-	SortBy               FindLocalBranchesRequest_SortBy `protobuf:"varint,2,opt,name=sort_by,json=sortBy,proto3,enum=gitaly.FindLocalBranchesRequest_SortBy" json:"sort_by,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
-	XXX_unrecognized     []byte                          `json:"-"`
-	XXX_sizecache        int32                           `json:"-"`
+	Repository *Repository                     `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
+	SortBy     FindLocalBranchesRequest_SortBy `protobuf:"varint,2,opt,name=sort_by,json=sortBy,proto3,enum=gitaly.FindLocalBranchesRequest_SortBy" json:"sort_by,omitempty"`
+	// The page token is the branch name, with the `refs/heads/` prefix, for
+	// example "refs/heads/master". After the first branch name is encountered
+	// which lexicographically exceeds the page token, it will be the first result
+	// send as part of the response.
+	PaginationParams     *PaginationParameter `protobuf:"bytes,3,opt,name=pagination_params,json=paginationParams,proto3" json:"pagination_params,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+	XXX_unrecognized     []byte               `json:"-"`
+	XXX_sizecache        int32                `json:"-"`
 }
 
 func (m *FindLocalBranchesRequest) Reset()         { *m = FindLocalBranchesRequest{} }
@@ -558,6 +563,13 @@ func (m *FindLocalBranchesRequest) GetSortBy() FindLocalBranchesRequest_SortBy {
 	return FindLocalBranchesRequest_NAME
 }
 
+func (m *FindLocalBranchesRequest) GetPaginationParams() *PaginationParameter {
+	if m != nil {
+		return m.PaginationParams
+	}
+	return nil
+}
+
 type FindLocalBranchesResponse struct {
 	Branches             []*FindLocalBranchResponse `protobuf:"bytes,1,rep,name=branches,proto3" json:"branches,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
@@ -2089,114 +2101,116 @@ func init() {
 func init() { proto.RegisterFile("ref.proto", fileDescriptor_65d958559ea81b29) }
 
 var fileDescriptor_65d958559ea81b29 = []byte{
-	// 1702 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0x5f, 0x6f, 0x1b, 0x4b,
-	0x15, 0xbf, 0xeb, 0x24, 0x8e, 0x7d, 0xec, 0x3a, 0x9b, 0xc9, 0x3f, 0x67, 0xd3, 0x36, 0xe9, 0xdc,
-	0xdb, 0x36, 0xa1, 0xc5, 0x29, 0xa9, 0x40, 0x48, 0x20, 0x81, 0x93, 0x98, 0x36, 0xb4, 0x75, 0xa2,
-	0xb1, 0x4b, 0x5b, 0x84, 0x58, 0xad, 0xed, 0xf1, 0x66, 0x61, 0xbd, 0x6b, 0x76, 0x27, 0x6d, 0x03,
-	0x6f, 0x94, 0x47, 0x24, 0x24, 0x10, 0x82, 0x07, 0x9e, 0x78, 0xe0, 0x23, 0xf0, 0x11, 0x78, 0x41,
-	0x7c, 0x21, 0x9e, 0xd0, 0xce, 0xcc, 0xfe, 0xb3, 0xd7, 0x4e, 0xa4, 0xb8, 0xe2, 0x3e, 0x79, 0xe7,
-	0xcc, 0x39, 0xbf, 0x73, 0xe6, 0xcc, 0x99, 0xf3, 0xc7, 0x50, 0xf4, 0x68, 0xbf, 0x36, 0xf4, 0x5c,
-	0xe6, 0xa2, 0xbc, 0x69, 0x31, 0xc3, 0xbe, 0xd4, 0xc0, 0xb6, 0x1c, 0x26, 0x68, 0x5a, 0xd9, 0x3f,
-	0x37, 0x3c, 0xda, 0x93, 0x2b, 0xe8, 0xd8, 0x6e, 0x47, 0x7e, 0x6f, 0x9b, 0xae, 0x6b, 0xda, 0x74,
-	0x9f, 0xaf, 0x3a, 0x17, 0xfd, 0x7d, 0x66, 0x0d, 0xa8, 0xcf, 0x8c, 0xc1, 0x50, 0x30, 0xe0, 0xdf,
-	0x2a, 0xb0, 0xf2, 0xd2, 0xf2, 0x59, 0x93, 0x7e, 0x38, 0xb4, 0xdd, 0x8e, 0x4f, 0xe8, 0xaf, 0x2e,
-	0xa8, 0xcf, 0xd0, 0x77, 0x01, 0x3c, 0x3a, 0x74, 0x7d, 0x8b, 0xb9, 0xde, 0x65, 0x55, 0xd9, 0x51,
-	0x76, 0x4b, 0x07, 0xa8, 0x26, 0x74, 0xd7, 0x48, 0xb4, 0x73, 0x38, 0xff, 0xd7, 0x7f, 0x3d, 0x56,
-	0x48, 0x82, 0x17, 0x6d, 0x41, 0xb1, 0xeb, 0x0e, 0x06, 0x16, 0xd3, 0xad, 0x5e, 0x35, 0xb7, 0xa3,
-	0xec, 0x16, 0x49, 0x41, 0x10, 0x4e, 0x7a, 0x68, 0x15, 0x16, 0x6c, 0x6b, 0x60, 0xb1, 0xea, 0xdc,
-	0x8e, 0xb2, 0x7b, 0x8b, 0x88, 0x05, 0x7e, 0x03, 0xab, 0x69, 0x1b, 0xfc, 0xa1, 0xeb, 0xf8, 0x14,
-	0xfd, 0x00, 0x54, 0x87, 0x7e, 0xd0, 0x83, 0xf3, 0xe8, 0x6e, 0xe7, 0x17, 0xb4, 0xcb, 0xfc, 0xaa,
-	0xb2, 0x33, 0xb7, 0x5b, 0x3a, 0x58, 0x0b, 0x4d, 0x91, 0x32, 0xa7, 0x7c, 0x97, 0x54, 0x9c, 0xe4,
-	0xd2, 0xc7, 0x6f, 0xe1, 0xf6, 0x8f, 0x2c, 0xa7, 0x77, 0x4c, 0xfb, 0xc6, 0x85, 0xcd, 0x0e, 0x3d,
-	0xc3, 0xe9, 0x9e, 0x37, 0x8d, 0x01, 0xbd, 0xf1, 0x29, 0xf1, 0x53, 0xb8, 0x33, 0x01, 0x59, 0xda,
-	0x8e, 0x60, 0xde, 0x31, 0x06, 0x94, 0x83, 0x96, 0x09, 0xff, 0xc6, 0xaf, 0x61, 0x33, 0x10, 0xaa,
-	0xdb, 0x76, 0x2c, 0x70, 0x73, 0x8f, 0xe3, 0x03, 0xd0, 0xb2, 0x60, 0xa5, 0x21, 0xab, 0xb0, 0x10,
-	0x28, 0x17, 0x9e, 0x2b, 0x13, 0xb1, 0xc0, 0x04, 0xd6, 0xa5, 0x4c, 0xdb, 0x30, 0x67, 0x64, 0xc7,
-	0x3e, 0x6c, 0x8c, 0x61, 0x4e, 0x35, 0xe2, 0x93, 0x02, 0x28, 0x90, 0x20, 0xb4, 0x3f, 0x93, 0x5b,
-	0x99, 0x1e, 0x7b, 0xeb, 0x90, 0x1f, 0x7a, 0xb4, 0x6f, 0x7d, 0xe4, 0xc1, 0x57, 0x26, 0x72, 0x85,
-	0xf7, 0x60, 0x25, 0x65, 0xc4, 0x94, 0x0b, 0xfc, 0x8f, 0x02, 0xd5, 0x80, 0xf7, 0xa5, 0xdb, 0x35,
-	0xa4, 0xb3, 0x67, 0xe0, 0x38, 0xf4, 0x43, 0x58, 0xf4, 0x5d, 0x8f, 0xe9, 0x9d, 0x4b, 0x6e, 0x74,
-	0xe5, 0xe0, 0x61, 0x28, 0x36, 0x49, 0x59, 0xad, 0xe5, 0x7a, 0xec, 0xf0, 0x92, 0xe4, 0x7d, 0xfe,
-	0x8b, 0xbf, 0x0d, 0x79, 0x41, 0x41, 0x05, 0x98, 0x6f, 0xd6, 0x5f, 0x35, 0xd4, 0x2f, 0xd0, 0x12,
-	0x94, 0x5e, 0x9f, 0x1d, 0xd7, 0xdb, 0x8d, 0x63, 0xbd, 0xde, 0x3a, 0x52, 0x15, 0xa4, 0x42, 0x39,
-	0x24, 0x1c, 0x37, 0x5a, 0x47, 0x6a, 0x0e, 0xbf, 0x15, 0x01, 0x39, 0xa2, 0x41, 0x3a, 0xe0, 0x7b,
-	0x50, 0xe8, 0x48, 0x9a, 0x7c, 0x75, 0xdb, 0x13, 0xcc, 0x0a, 0x45, 0x48, 0x24, 0x80, 0xff, 0x99,
-	0x13, 0xc1, 0x90, 0xc1, 0x95, 0xe5, 0xd9, 0xe9, 0x37, 0x77, 0x1f, 0x2a, 0x72, 0xd3, 0xbf, 0xe0,
-	0x2f, 0x5b, 0xde, 0xe0, 0x2d, 0x41, 0x6d, 0x09, 0x22, 0x7a, 0x0e, 0x92, 0xa0, 0x1b, 0x17, 0xec,
-	0xdc, 0xf5, 0xaa, 0xf3, 0xfc, 0x0e, 0xbe, 0x9c, 0x60, 0xf5, 0x11, 0xe7, 0xad, 0x73, 0x56, 0x52,
-	0xee, 0x26, 0x56, 0xa8, 0x09, 0xaa, 0x44, 0x12, 0x3f, 0x8c, 0x7a, 0xd5, 0x85, 0xeb, 0x83, 0x2d,
-	0x09, 0xa9, 0xa3, 0x50, 0x16, 0xed, 0x41, 0x5e, 0x90, 0xaa, 0x79, 0x8e, 0xb2, 0x1c, 0xa2, 0x3c,
-	0x0b, 0xb9, 0x88, 0x64, 0xc0, 0x7f, 0x52, 0x60, 0x6b, 0x0a, 0x76, 0xa6, 0xf3, 0x56, 0x61, 0x81,
-	0x0e, 0x0c, 0xcb, 0xe6, 0x8e, 0x2b, 0x13, 0xb1, 0x40, 0x35, 0x98, 0xef, 0x19, 0x8c, 0x72, 0x5f,
-	0x95, 0x0e, 0xb4, 0x9a, 0x28, 0x05, 0xb5, 0xb0, 0x14, 0xd4, 0xda, 0x61, 0x29, 0x20, 0x9c, 0x0f,
-	0x69, 0x50, 0x08, 0xaa, 0xc3, 0xaf, 0x5d, 0x87, 0x72, 0xcf, 0x95, 0x49, 0xb4, 0xc6, 0x7f, 0x53,
-	0xa2, 0x7c, 0x31, 0xbb, 0xb0, 0xdf, 0x86, 0xd2, 0x80, 0x7a, 0x26, 0xed, 0xe9, 0xae, 0x63, 0x8b,
-	0xd0, 0x2f, 0x10, 0x10, 0xa4, 0x53, 0xc7, 0xbe, 0x44, 0x0f, 0x61, 0x49, 0x32, 0x44, 0x81, 0x38,
-	0xc7, 0xf3, 0x47, 0x45, 0x90, 0x43, 0x53, 0xf0, 0x3f, 0x94, 0x28, 0xf5, 0x8c, 0x85, 0xf1, 0xe1,
-	0x58, 0x18, 0x3f, 0x48, 0xde, 0x61, 0x86, 0x48, 0x4d, 0xc6, 0x6b, 0x24, 0xa7, 0x3d, 0x83, 0xbc,
-	0xa0, 0x65, 0xba, 0x7f, 0x0f, 0xf2, 0xcc, 0xf0, 0x4c, 0xca, 0xf8, 0x11, 0xb2, 0x6f, 0x57, 0x30,
-	0x60, 0x0a, 0x95, 0x40, 0x69, 0xdb, 0x30, 0x6f, 0xee, 0xbe, 0x4d, 0x28, 0x30, 0xc3, 0xd4, 0xb9,
-	0x39, 0xe2, 0xe2, 0x17, 0x99, 0xc8, 0xbb, 0xf8, 0x09, 0x2c, 0x45, 0x6a, 0xa4, 0x1b, 0xee, 0xc0,
-	0x1c, 0x33, 0x4c, 0xa9, 0xa0, 0x14, 0x2a, 0x08, 0x38, 0x02, 0x3a, 0x6e, 0x8a, 0x4c, 0x2c, 0x72,
-	0xf7, 0x0c, 0x6a, 0xc1, 0x77, 0x44, 0x52, 0x8d, 0xf0, 0xa4, 0x15, 0xdb, 0x30, 0xcf, 0x0c, 0x33,
-	0xbc, 0x88, 0x94, 0x19, 0x7c, 0x03, 0xff, 0x1c, 0x54, 0x42, 0xfb, 0x8d, 0x8f, 0x96, 0xcf, 0x66,
-	0x10, 0x61, 0x2a, 0xcc, 0x79, 0xb4, 0x2f, 0xbd, 0x13, 0x7c, 0xe2, 0x3d, 0x58, 0x4e, 0xe0, 0xc7,
-	0xd5, 0xe9, 0xbd, 0x61, 0x5f, 0x88, 0x5b, 0x2d, 0x10, 0xb1, 0xc0, 0xbf, 0x53, 0x60, 0xe5, 0xc8,
-	0xa3, 0x06, 0xa3, 0x61, 0xfe, 0xba, 0xa9, 0x39, 0x61, 0xf0, 0xe4, 0x12, 0xc1, 0xb3, 0x0d, 0x25,
-	0x9f, 0x19, 0x1e, 0xd3, 0x87, 0xae, 0xe5, 0x84, 0x89, 0x0d, 0x38, 0xe9, 0x2c, 0xa0, 0xe0, 0x7f,
-	0x2b, 0xb0, 0x9a, 0x36, 0x23, 0xca, 0xcf, 0x79, 0x9f, 0x19, 0xec, 0xc2, 0xe7, 0x36, 0x54, 0xe2,
-	0xd4, 0x94, 0xc5, 0x5d, 0x6b, 0x71, 0x56, 0x22, 0x45, 0xd0, 0x03, 0xc8, 0x8b, 0xe8, 0x96, 0x31,
-	0x5b, 0x09, 0x85, 0xa5, 0x98, 0xdc, 0xc5, 0x4d, 0xc8, 0x0b, 0x49, 0x94, 0x87, 0xdc, 0xe9, 0x0b,
-	0xf5, 0x0b, 0x54, 0x01, 0x68, 0x10, 0xa2, 0x37, 0xde, 0x9e, 0xb4, 0xda, 0x2d, 0x55, 0x09, 0xca,
-	0x4c, 0xb0, 0x3e, 0x69, 0xfe, 0xa4, 0xfe, 0xf2, 0xe4, 0x58, 0xcd, 0xa1, 0x2d, 0xd8, 0x48, 0x10,
-	0xf4, 0x56, 0xbb, 0x4e, 0xda, 0xfa, 0xd9, 0xe9, 0x49, 0xb3, 0xad, 0xce, 0xe1, 0x2e, 0xac, 0x1c,
-	0x53, 0x9b, 0x7e, 0x56, 0x9f, 0xe2, 0x75, 0x58, 0x4d, 0x2b, 0x11, 0x3e, 0xc0, 0x06, 0x2c, 0x07,
-	0x41, 0xf9, 0x39, 0x55, 0x7f, 0x5f, 0xbc, 0xa3, 0x91, 0xab, 0x8a, 0xbd, 0xad, 0x4c, 0xf5, 0xf6,
-	0x1f, 0x14, 0x58, 0x16, 0x96, 0x13, 0xda, 0x9f, 0x41, 0xfc, 0x3f, 0x06, 0x44, 0x3f, 0x76, 0xe9,
-	0x90, 0xe9, 0x1f, 0x2c, 0x76, 0xae, 0xcb, 0xf6, 0x27, 0xc7, 0x73, 0xa8, 0x2a, 0x76, 0xde, 0x58,
-	0xec, 0xfc, 0x8c, 0xd3, 0x83, 0xf3, 0x78, 0xb4, 0x1f, 0xe6, 0x58, 0xfe, 0x8d, 0xbf, 0x05, 0x28,
-	0x69, 0x90, 0x3c, 0xcf, 0x16, 0x14, 0x4d, 0x8b, 0xe9, 0xd4, 0xf3, 0x5c, 0x8f, 0x1b, 0x54, 0x24,
-	0x05, 0xd3, 0x62, 0x8d, 0x60, 0x8d, 0xff, 0xac, 0xc0, 0x83, 0xa0, 0x9d, 0x4f, 0x34, 0xa3, 0x47,
-	0xae, 0xc3, 0x0c, 0xcb, 0xb1, 0x1c, 0x53, 0xe6, 0xc3, 0xff, 0xc7, 0x94, 0x41, 0xe0, 0xe1, 0x95,
-	0x66, 0xc9, 0xf3, 0xdd, 0x83, 0xb2, 0xb8, 0x11, 0x5d, 0x74, 0xad, 0xc2, 0x63, 0xa5, 0x4e, 0x2c,
-	0xfa, 0xe3, 0xf9, 0x82, 0xa2, 0xe6, 0xf0, 0x1f, 0x15, 0xf8, 0x32, 0x00, 0x0d, 0x1b, 0xde, 0xaf,
-	0xc5, 0x41, 0x4f, 0xe0, 0xab, 0xe9, 0x36, 0xc5, 0xb7, 0x18, 0x16, 0x90, 0xf0, 0x88, 0x05, 0x59,
-	0x41, 0xc2, 0xf3, 0xfd, 0x06, 0xd6, 0x9e, 0xd1, 0x00, 0xe9, 0x15, 0xf5, 0x7d, 0xc3, 0x9c, 0x45,
-	0xd5, 0xdf, 0x80, 0xa0, 0x4c, 0xe9, 0x56, 0x4f, 0x04, 0x5a, 0x31, 0xa8, 0x8d, 0xe6, 0x49, 0x2f,
-	0xd0, 0x98, 0x53, 0xe7, 0x48, 0x6c, 0x12, 0x7e, 0x07, 0xeb, 0xa3, 0xca, 0xa5, 0xe5, 0x55, 0x58,
-	0x1c, 0x08, 0x5a, 0x58, 0xf9, 0xe4, 0x12, 0xad, 0x05, 0xb5, 0x38, 0x40, 0xe7, 0x2e, 0x29, 0x92,
-	0x05, 0x0e, 0x2e, 0x4e, 0x43, 0xa2, 0x7a, 0x89, 0x1d, 0x58, 0x93, 0x13, 0xa7, 0xf0, 0xc9, 0x67,
-	0x9e, 0x7b, 0x71, 0x03, 0xd6, 0x47, 0xf5, 0xc9, 0xa3, 0x3c, 0x82, 0x45, 0xc1, 0x15, 0x16, 0xc5,
-	0x8c, 0xee, 0x21, 0xe4, 0xc0, 0x97, 0x62, 0x9e, 0xad, 0xdb, 0x36, 0xa1, 0x03, 0x37, 0xcc, 0x6f,
-	0x33, 0xea, 0xc5, 0x3c, 0x0e, 0x19, 0xf7, 0x13, 0xc5, 0x80, 0x21, 0x20, 0xf1, 0x96, 0xe2, 0x85,
-	0x18, 0x78, 0x33, 0x54, 0xcb, 0x83, 0x7c, 0x63, 0xac, 0xcf, 0x1a, 0xcd, 0x72, 0xf1, 0x74, 0xd0,
-	0x87, 0xa5, 0x33, 0xa3, 0xfb, 0xcb, 0xd9, 0x24, 0xb9, 0x4d, 0x28, 0x18, 0xb6, 0xad, 0xf3, 0xd4,
-	0x25, 0x7a, 0xc8, 0x45, 0x23, 0xb0, 0xb2, 0xef, 0x63, 0x04, 0x6a, 0xac, 0x47, 0xd8, 0x79, 0xf0,
-	0xf7, 0x5b, 0x00, 0x84, 0xf6, 0x5b, 0xd4, 0x7b, 0x6f, 0x75, 0x29, 0xb2, 0x61, 0x2d, 0x73, 0x90,
-	0x47, 0x5f, 0x25, 0xbb, 0xc4, 0x49, 0xff, 0x20, 0x68, 0xf7, 0xaf, 0xe0, 0x92, 0x95, 0x27, 0xff,
-	0xdf, 0xbf, 0xec, 0xe6, 0x0a, 0x39, 0x44, 0xa3, 0x36, 0x2b, 0x91, 0x86, 0xd0, 0xbd, 0xcc, 0x86,
-	0x34, 0x39, 0x95, 0x6b, 0x78, 0x1a, 0x4b, 0x5a, 0xc9, 0x13, 0x05, 0xfd, 0x4c, 0xf4, 0x7f, 0x89,
-	0x49, 0x1c, 0xdd, 0x1d, 0x01, 0x18, 0x19, 0xfb, 0xb5, 0xed, 0x89, 0xfb, 0x63, 0xe8, 0x4d, 0x28,
-	0x25, 0x06, 0x66, 0xa4, 0x25, 0x25, 0xd3, 0xa3, 0xbc, 0xb6, 0x95, 0xb9, 0x37, 0xe2, 0x94, 0x8e,
-	0x28, 0xcb, 0xa9, 0x29, 0x14, 0xed, 0x5c, 0x35, 0x02, 0x6b, 0xf7, 0xa6, 0x70, 0x4c, 0xf1, 0x48,
-	0xa4, 0xe1, 0xee, 0xc4, 0x31, 0x20, 0xdb, 0x23, 0x53, 0xd0, 0xcf, 0x84, 0x47, 0x64, 0xb7, 0x9b,
-	0xf6, 0x48, 0xba, 0xa5, 0x4e, 0x7b, 0x64, 0xa4, 0x3d, 0x4e, 0x20, 0x1e, 0xc2, 0xa2, 0xec, 0xe0,
-	0xd1, 0x7a, 0x52, 0x22, 0x9e, 0x1c, 0xb4, 0x8d, 0x31, 0xfa, 0x88, 0x5f, 0x1d, 0x11, 0xda, 0x63,
-	0x4f, 0x36, 0x1d, 0xda, 0x93, 0x92, 0x49, 0x3a, 0xb4, 0x27, 0xbe, 0xfb, 0x84, 0xcd, 0xcf, 0xa1,
-	0x18, 0xf5, 0xd6, 0xa8, 0x1a, 0xbf, 0xdd, 0x74, 0x3b, 0xaf, 0x6d, 0x66, 0xec, 0x8c, 0x58, 0xfe,
-	0x02, 0x20, 0xee, 0xa2, 0xd0, 0x66, 0xd2, 0x90, 0x54, 0xf3, 0xa6, 0x69, 0x59, 0x5b, 0xe3, 0x60,
-	0x71, 0x0b, 0x13, 0x83, 0x8d, 0xf5, 0x59, 0x31, 0xd8, 0x78, 0xc7, 0x23, 0xc1, 0x14, 0xf4, 0x7b,
-	0x05, 0xb6, 0xaf, 0xe8, 0x22, 0x50, 0x2d, 0xc4, 0xb9, 0x5e, 0x17, 0xa4, 0xed, 0x5f, 0x9b, 0x7f,
-	0xcc, 0xe5, 0x9f, 0x14, 0xb8, 0x3d, 0xad, 0xd6, 0xa3, 0x47, 0x49, 0xec, 0x2b, 0xba, 0x14, 0xed,
-	0xf1, 0xf5, 0x98, 0xc7, 0xac, 0x78, 0x07, 0x95, 0x74, 0xa1, 0x46, 0x77, 0xa2, 0x22, 0x96, 0xd5,
-	0x3d, 0x68, 0x77, 0x27, 0x6d, 0x67, 0x41, 0xa7, 0x0b, 0x67, 0x0c, 0x9d, 0x59, 0xc0, 0x63, 0xe8,
-	0xec, 0x7a, 0x9b, 0x80, 0x6e, 0x41, 0x39, 0xf9, 0xaf, 0x33, 0xda, 0x1a, 0x91, 0x4c, 0xfe, 0x1f,
-	0xae, 0xdd, 0xce, 0xde, 0x1c, 0x03, 0x6d, 0x40, 0x21, 0xac, 0x38, 0x28, 0x7a, 0xa0, 0x23, 0xb5,
-	0x4e, 0xab, 0x8e, 0x6f, 0xa4, 0xc3, 0xec, 0xf0, 0xc9, 0x4f, 0x03, 0x16, 0xdb, 0xe8, 0xd4, 0xba,
-	0xee, 0x60, 0x5f, 0x7c, 0x7e, 0xd3, 0xf5, 0xcc, 0x7d, 0x21, 0x28, 0xfe, 0xcf, 0xdf, 0x37, 0x5d,
-	0xb9, 0x1e, 0x76, 0x3a, 0x79, 0x4e, 0x7a, 0xfa, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x08, 0x97,
-	0xa3, 0xee, 0x2b, 0x18, 0x00, 0x00,
+	// 1742 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0x5f, 0x73, 0x1b, 0x49,
+	0x11, 0xbf, 0x95, 0x6d, 0x59, 0x6a, 0x29, 0xf2, 0x7a, 0xe2, 0x3f, 0xf2, 0x3a, 0x89, 0x9d, 0xb9,
+	0xbb, 0xc4, 0xe1, 0x82, 0x1c, 0x7c, 0x05, 0x45, 0x15, 0x54, 0x81, 0xff, 0x88, 0xc4, 0x24, 0xa7,
+	0xa8, 0x46, 0x3a, 0x2e, 0x47, 0x51, 0x6c, 0x8d, 0xa4, 0xd1, 0x7a, 0x61, 0xb5, 0x2b, 0x76, 0xc7,
+	0x97, 0x18, 0xde, 0x38, 0x1e, 0xa9, 0xa2, 0x0a, 0x8a, 0x0a, 0x0f, 0x3c, 0xf1, 0xc0, 0x47, 0xe0,
+	0x23, 0xf0, 0xc2, 0x37, 0xe2, 0x89, 0xda, 0x99, 0xd9, 0x7f, 0xd2, 0x4a, 0x4e, 0x95, 0x95, 0xe2,
+	0x9e, 0xb4, 0xd3, 0xd3, 0xfd, 0x9b, 0xdf, 0xf4, 0xf4, 0x76, 0xf7, 0xac, 0xa0, 0xec, 0xb3, 0x61,
+	0x63, 0xec, 0x7b, 0xdc, 0x43, 0x45, 0xcb, 0xe6, 0xd4, 0xb9, 0x32, 0xc0, 0xb1, 0x5d, 0x2e, 0x65,
+	0x46, 0x35, 0xb8, 0xa0, 0x3e, 0x1b, 0xa8, 0x11, 0xf4, 0x1c, 0xaf, 0xa7, 0x9e, 0xf7, 0x2c, 0xcf,
+	0xb3, 0x1c, 0x76, 0x28, 0x46, 0xbd, 0xcb, 0xe1, 0x21, 0xb7, 0x47, 0x2c, 0xe0, 0x74, 0x34, 0x96,
+	0x0a, 0xf8, 0xf7, 0x1a, 0xdc, 0x7e, 0x61, 0x07, 0xbc, 0xc5, 0x5e, 0x9f, 0x38, 0x5e, 0x2f, 0x20,
+	0xec, 0x37, 0x97, 0x2c, 0xe0, 0xe8, 0xfb, 0x00, 0x3e, 0x1b, 0x7b, 0x81, 0xcd, 0x3d, 0xff, 0xaa,
+	0xae, 0xed, 0x6b, 0x07, 0x95, 0x23, 0xd4, 0x90, 0x6b, 0x37, 0x48, 0x3c, 0x73, 0xb2, 0xfc, 0xb7,
+	0x7f, 0x3f, 0xd6, 0x48, 0x4a, 0x17, 0xed, 0x42, 0xb9, 0xef, 0x8d, 0x46, 0x36, 0x37, 0xed, 0x41,
+	0xbd, 0xb0, 0xaf, 0x1d, 0x94, 0x49, 0x49, 0x0a, 0xce, 0x07, 0x68, 0x03, 0x56, 0x1c, 0x7b, 0x64,
+	0xf3, 0xfa, 0xd2, 0xbe, 0x76, 0x70, 0x8b, 0xc8, 0x01, 0xfe, 0x02, 0x36, 0xb2, 0x1c, 0x82, 0xb1,
+	0xe7, 0x06, 0x0c, 0xfd, 0x08, 0x74, 0x97, 0xbd, 0x36, 0xc3, 0xfd, 0x98, 0x5e, 0xef, 0x57, 0xac,
+	0xcf, 0x83, 0xba, 0xb6, 0xbf, 0x74, 0x50, 0x39, 0xda, 0x8c, 0xa8, 0x28, 0x9b, 0x97, 0x62, 0x96,
+	0xd4, 0xdc, 0xf4, 0x30, 0xc0, 0xaf, 0xe0, 0xce, 0x4f, 0x6c, 0x77, 0x70, 0xc6, 0x86, 0xf4, 0xd2,
+	0xe1, 0x27, 0x3e, 0x75, 0xfb, 0x17, 0x2d, 0x3a, 0x62, 0x37, 0xde, 0x25, 0xfe, 0x14, 0xee, 0xce,
+	0x40, 0x56, 0xdc, 0x11, 0x2c, 0xbb, 0x74, 0xc4, 0x04, 0x68, 0x95, 0x88, 0x67, 0xfc, 0x39, 0xec,
+	0x84, 0x46, 0xc7, 0x8e, 0x93, 0x18, 0xdc, 0xdc, 0xe3, 0xf8, 0x08, 0x8c, 0x3c, 0x58, 0x45, 0x64,
+	0x03, 0x56, 0xc2, 0xc5, 0xa5, 0xe7, 0xaa, 0x44, 0x0e, 0x30, 0x81, 0x2d, 0x65, 0xd3, 0xa5, 0xd6,
+	0x82, 0x78, 0x1c, 0xc2, 0xf6, 0x14, 0xe6, 0x5c, 0x12, 0x5f, 0x6b, 0x80, 0x42, 0x0b, 0xc2, 0x86,
+	0x0b, 0x39, 0x95, 0xf9, 0xb1, 0xb7, 0x05, 0xc5, 0xb1, 0xcf, 0x86, 0xf6, 0x1b, 0x11, 0x7c, 0x55,
+	0xa2, 0x46, 0xf8, 0x11, 0xdc, 0xce, 0x90, 0x98, 0x73, 0x80, 0x6f, 0x0b, 0x50, 0x0f, 0x75, 0x5f,
+	0x78, 0x7d, 0xaa, 0x9c, 0xbd, 0x00, 0xc7, 0xa1, 0x1f, 0xc3, 0x6a, 0xe0, 0xf9, 0xdc, 0xec, 0x5d,
+	0x09, 0xd2, 0xb5, 0xa3, 0x87, 0x91, 0xd9, 0xac, 0xc5, 0x1a, 0x1d, 0xcf, 0xe7, 0x27, 0x57, 0xa4,
+	0x18, 0x88, 0x5f, 0xf4, 0x0c, 0xd6, 0xc7, 0xd4, 0xb2, 0x5d, 0xca, 0x6d, 0xcf, 0x35, 0xc7, 0xd4,
+	0xa7, 0xa3, 0x40, 0x6c, 0xb3, 0x72, 0xb4, 0x1b, 0x61, 0xb5, 0x63, 0x85, 0x76, 0x38, 0xcf, 0x38,
+	0xf3, 0x89, 0x3e, 0xce, 0x0a, 0x03, 0xfc, 0x5d, 0x28, 0x4a, 0x6c, 0x54, 0x82, 0xe5, 0xd6, 0xf1,
+	0x67, 0x4d, 0xfd, 0x03, 0xb4, 0x06, 0x95, 0xcf, 0xdb, 0x67, 0xc7, 0xdd, 0xe6, 0x99, 0x79, 0xdc,
+	0x39, 0xd5, 0x35, 0xa4, 0x43, 0x35, 0x12, 0x9c, 0x35, 0x3b, 0xa7, 0x7a, 0x01, 0xbf, 0x92, 0xa1,
+	0x3d, 0xc1, 0x55, 0xb9, 0xf2, 0x07, 0x50, 0xea, 0x29, 0x99, 0x7a, 0x7f, 0xf7, 0x66, 0x6c, 0x30,
+	0x32, 0x21, 0xb1, 0x01, 0xfe, 0x57, 0x41, 0x86, 0x55, 0x8e, 0x56, 0xde, 0x19, 0xcd, 0x8f, 0x81,
+	0x8f, 0xa1, 0xa6, 0x26, 0x83, 0x4b, 0x91, 0x23, 0x54, 0x2c, 0xdc, 0x92, 0xd2, 0x8e, 0x14, 0xa2,
+	0x67, 0xa0, 0x04, 0x26, 0xbd, 0xe4, 0x17, 0x9e, 0x5f, 0x5f, 0x16, 0xae, 0xfc, 0x70, 0x06, 0xeb,
+	0x53, 0xa1, 0x7b, 0x2c, 0x54, 0x49, 0xb5, 0x9f, 0x1a, 0xa1, 0x16, 0xe8, 0x0a, 0x49, 0xfe, 0x70,
+	0xe6, 0xd7, 0x57, 0xde, 0x1d, 0x6c, 0x4d, 0x5a, 0x9d, 0x46, 0xb6, 0xe8, 0x11, 0x14, 0xa5, 0xa8,
+	0x5e, 0x14, 0x28, 0xeb, 0x11, 0xca, 0xd3, 0x48, 0x8b, 0x28, 0x05, 0xfc, 0x17, 0x0d, 0x76, 0xe7,
+	0x60, 0xe7, 0x3a, 0x6f, 0x03, 0x56, 0xd8, 0x88, 0xda, 0x8e, 0x70, 0x5c, 0x95, 0xc8, 0x01, 0x6a,
+	0xc0, 0xf2, 0x80, 0x72, 0xa6, 0x02, 0xca, 0x68, 0xc8, 0xa2, 0xd2, 0x88, 0x8a, 0x4a, 0xa3, 0x1b,
+	0x15, 0x15, 0x22, 0xf4, 0x90, 0x01, 0xa5, 0xb0, 0xce, 0xfc, 0xd6, 0x73, 0x99, 0xf0, 0x5c, 0x95,
+	0xc4, 0x63, 0xfc, 0x77, 0x2d, 0xce, 0x3c, 0x8b, 0x7b, 0x81, 0xf6, 0xa0, 0x32, 0x62, 0xbe, 0xc5,
+	0x06, 0xa6, 0xe7, 0x3a, 0xf2, 0x25, 0x2a, 0x11, 0x90, 0xa2, 0x97, 0xae, 0x73, 0x85, 0x1e, 0xc2,
+	0x9a, 0x52, 0x88, 0x03, 0x71, 0x49, 0x64, 0xa2, 0x9a, 0x14, 0x47, 0x54, 0xf0, 0x3f, 0xb5, 0x38,
+	0x89, 0x4d, 0x85, 0xf1, 0xc9, 0x54, 0x18, 0x3f, 0x48, 0x9f, 0x61, 0x8e, 0x49, 0x43, 0xc5, 0x6b,
+	0x6c, 0x67, 0x3c, 0x85, 0xa2, 0x94, 0xe5, 0xba, 0xff, 0x11, 0x14, 0x39, 0xf5, 0x2d, 0xc6, 0xc5,
+	0x16, 0xf2, 0x4f, 0x57, 0x2a, 0x60, 0x06, 0xb5, 0x70, 0xd1, 0x2e, 0xb5, 0x6e, 0xee, 0xbe, 0x1d,
+	0x28, 0x71, 0x6a, 0x99, 0x82, 0x8e, 0x3c, 0xf8, 0x55, 0x2e, 0x33, 0x38, 0x7e, 0x02, 0x6b, 0xf1,
+	0x32, 0xca, 0x0d, 0x77, 0x61, 0x89, 0x53, 0x4b, 0x2d, 0x50, 0x89, 0x16, 0x08, 0x35, 0x42, 0x39,
+	0x6e, 0xc9, 0x9c, 0x2e, 0xab, 0xc0, 0x02, 0xaa, 0xca, 0xf7, 0x64, 0x7a, 0x8e, 0xf1, 0x14, 0x8b,
+	0x3d, 0x58, 0xe6, 0xd4, 0x8a, 0x0e, 0x22, 0x43, 0x43, 0x4c, 0xe0, 0x5f, 0x82, 0x4e, 0xd8, 0xb0,
+	0xf9, 0xc6, 0x0e, 0xf8, 0x02, 0x22, 0x4c, 0x87, 0x25, 0x9f, 0x0d, 0x95, 0x77, 0xc2, 0x47, 0xfc,
+	0x08, 0xd6, 0x53, 0xf8, 0x49, 0x9d, 0xfb, 0x8a, 0x3a, 0x97, 0xf2, 0x54, 0x4b, 0x44, 0x0e, 0xf0,
+	0x1f, 0x34, 0xb8, 0x7d, 0xea, 0x33, 0xca, 0x59, 0x94, 0xbf, 0x6e, 0x4a, 0x27, 0x0a, 0x9e, 0x42,
+	0x2a, 0x78, 0xf6, 0xa0, 0x12, 0x70, 0xea, 0x73, 0x73, 0xec, 0xd9, 0x6e, 0x94, 0xd8, 0x40, 0x88,
+	0xda, 0xa1, 0x04, 0xff, 0x47, 0x83, 0x8d, 0x2c, 0x8d, 0x38, 0x3f, 0x17, 0x03, 0x4e, 0xf9, 0x65,
+	0x20, 0x38, 0xd4, 0x92, 0xd4, 0x94, 0xa7, 0xdd, 0xe8, 0x08, 0x55, 0xa2, 0x4c, 0xd0, 0x03, 0x28,
+	0xca, 0xe8, 0x56, 0x31, 0x5b, 0x8b, 0x8c, 0x95, 0x99, 0x9a, 0xc5, 0x2d, 0x28, 0x4a, 0x4b, 0x54,
+	0x84, 0xc2, 0xcb, 0xe7, 0xfa, 0x07, 0xa8, 0x06, 0xd0, 0x24, 0xc4, 0x6c, 0xbe, 0x3a, 0xef, 0x74,
+	0x3b, 0xba, 0x16, 0x96, 0x99, 0x70, 0x7c, 0xde, 0xfa, 0xd9, 0xf1, 0x8b, 0xf3, 0x33, 0xbd, 0x80,
+	0x76, 0x61, 0x3b, 0x25, 0x30, 0x3b, 0xdd, 0x63, 0xd2, 0x35, 0xdb, 0x2f, 0xcf, 0x5b, 0x5d, 0x7d,
+	0x09, 0xf7, 0xe1, 0xf6, 0x19, 0x73, 0xd8, 0x7b, 0xf5, 0x29, 0xde, 0x82, 0x8d, 0xec, 0x22, 0xd2,
+	0x07, 0x98, 0xc2, 0x7a, 0x18, 0x94, 0xef, 0x73, 0xe9, 0x1f, 0xca, 0xf7, 0x68, 0xe2, 0xa8, 0x12,
+	0x6f, 0x6b, 0x73, 0xbd, 0xfd, 0x27, 0x0d, 0xd6, 0x25, 0x73, 0xc2, 0x86, 0x0b, 0x88, 0xff, 0xc7,
+	0x80, 0xd8, 0x9b, 0x3e, 0x1b, 0x73, 0xf3, 0xb5, 0xcd, 0x2f, 0x4c, 0xd5, 0x48, 0x15, 0x44, 0x0e,
+	0xd5, 0xe5, 0xcc, 0x17, 0x36, 0xbf, 0x68, 0x0b, 0x79, 0xb8, 0x1f, 0x9f, 0x0d, 0xa3, 0x1c, 0x2b,
+	0x9e, 0xf1, 0x77, 0x00, 0xa5, 0x09, 0xa9, 0xfd, 0xec, 0x42, 0xd9, 0xb2, 0xb9, 0xc9, 0x7c, 0xdf,
+	0xf3, 0x05, 0xa1, 0x32, 0x29, 0x59, 0x36, 0x6f, 0x86, 0x63, 0xfc, 0x57, 0x0d, 0x1e, 0x84, 0x17,
+	0x83, 0x54, 0x5b, 0x7b, 0xea, 0xb9, 0x9c, 0xda, 0xae, 0xed, 0x5a, 0x2a, 0x1f, 0xfe, 0x3f, 0xee,
+	0x2b, 0x04, 0x1e, 0x5e, 0x4b, 0x4b, 0xed, 0xef, 0x3e, 0x54, 0xe5, 0x89, 0x98, 0xb2, 0xff, 0x95,
+	0x1e, 0xab, 0xf4, 0x12, 0xd3, 0x9f, 0x2e, 0x97, 0x34, 0xbd, 0x80, 0xff, 0xac, 0xc1, 0x87, 0x21,
+	0x68, 0xd4, 0x3a, 0x7f, 0x23, 0x36, 0x7a, 0x0e, 0x1f, 0xcd, 0xe7, 0x94, 0x9c, 0x62, 0x54, 0x40,
+	0xa2, 0x2d, 0x96, 0x54, 0x05, 0x89, 0xf6, 0xf7, 0x3b, 0xd8, 0x7c, 0xca, 0x42, 0xa4, 0xcf, 0x58,
+	0x10, 0x50, 0x6b, 0x11, 0x55, 0x7f, 0x1b, 0xc2, 0x32, 0x65, 0xda, 0x03, 0x19, 0x68, 0xe5, 0xb0,
+	0x36, 0x5a, 0xe7, 0x83, 0x70, 0xc5, 0x82, 0xbe, 0x44, 0x12, 0x4a, 0xf8, 0x4b, 0xd8, 0x9a, 0x5c,
+	0x5c, 0x31, 0xaf, 0xc3, 0xea, 0x48, 0xca, 0xa2, 0xca, 0xa7, 0x86, 0x68, 0x33, 0xac, 0xc5, 0x21,
+	0xba, 0x70, 0x49, 0x99, 0xac, 0x08, 0x70, 0xb9, 0x1b, 0x12, 0xd7, 0x4b, 0xec, 0xc2, 0xa6, 0xba,
+	0xbb, 0x4a, 0x9f, 0xbc, 0xe7, 0x1b, 0x34, 0x6e, 0xc2, 0xd6, 0xe4, 0x7a, 0x6a, 0x2b, 0x9f, 0xc0,
+	0xaa, 0xd4, 0x8a, 0x8a, 0x62, 0x4e, 0xf7, 0x10, 0x69, 0xe0, 0x2b, 0x79, 0x33, 0x3e, 0x76, 0x1c,
+	0xc2, 0x46, 0x5e, 0x94, 0xdf, 0x16, 0xd4, 0x8b, 0xf9, 0x02, 0x32, 0xe9, 0x27, 0xca, 0xa1, 0x42,
+	0x28, 0x12, 0x2d, 0xc5, 0x73, 0x79, 0x75, 0xce, 0x59, 0x5a, 0x6d, 0xe4, 0x5b, 0x53, 0x7d, 0xd6,
+	0x64, 0x96, 0x4b, 0x6e, 0x07, 0x43, 0x58, 0x6b, 0xd3, 0xfe, 0xaf, 0x17, 0x93, 0xe4, 0x76, 0xa0,
+	0x44, 0x1d, 0xc7, 0x14, 0xa9, 0x4b, 0xf6, 0x90, 0xab, 0x34, 0x64, 0x39, 0x0c, 0x30, 0x02, 0x3d,
+	0x59, 0x47, 0xf2, 0x3c, 0xfa, 0xc7, 0x2d, 0x00, 0xc2, 0x86, 0x1d, 0xe6, 0x7f, 0x65, 0xf7, 0x19,
+	0x72, 0x60, 0x33, 0xf7, 0x93, 0x00, 0xfa, 0x28, 0xdd, 0x25, 0xce, 0xfa, 0x16, 0x61, 0x7c, 0x7c,
+	0x8d, 0x96, 0xaa, 0x3c, 0xc5, 0xff, 0xbe, 0x3d, 0x28, 0x94, 0x0a, 0x88, 0xc5, 0x6d, 0x56, 0x2a,
+	0x0d, 0xa1, 0xfb, 0xb9, 0x0d, 0x69, 0xfa, 0x7e, 0x6f, 0xe0, 0x79, 0x2a, 0xd9, 0x45, 0x9e, 0x68,
+	0xe8, 0x17, 0xb2, 0xff, 0x4b, 0xdd, 0xe9, 0xd1, 0xbd, 0x09, 0x80, 0x89, 0x0f, 0x08, 0xc6, 0xde,
+	0xcc, 0xf9, 0x29, 0xf4, 0x16, 0x54, 0x52, 0x57, 0x6f, 0x64, 0xa4, 0x2d, 0xb3, 0x1f, 0x05, 0x8c,
+	0xdd, 0xdc, 0xb9, 0x09, 0xa7, 0xf4, 0x64, 0x59, 0xce, 0xdc, 0x42, 0xd1, 0xfe, 0x75, 0x97, 0x69,
+	0xe3, 0xfe, 0x1c, 0x8d, 0x39, 0x1e, 0x89, 0x57, 0xb8, 0x37, 0xf3, 0x1a, 0x90, 0xef, 0x91, 0x39,
+	0xe8, 0x6d, 0xe9, 0x11, 0xd5, 0xed, 0x66, 0x3d, 0x92, 0x6d, 0xa9, 0xb3, 0x1e, 0x99, 0x68, 0x8f,
+	0x53, 0x88, 0x27, 0xb0, 0xaa, 0x3a, 0x78, 0xb4, 0x95, 0xb6, 0x48, 0x6e, 0x0e, 0xc6, 0xf6, 0x94,
+	0x7c, 0xc2, 0xaf, 0xae, 0x0c, 0xed, 0xa9, 0x57, 0x36, 0x1b, 0xda, 0xb3, 0x92, 0x49, 0x36, 0xb4,
+	0x67, 0xbe, 0xf7, 0x29, 0xce, 0xcf, 0xa0, 0x1c, 0xf7, 0xd6, 0xa8, 0x9e, 0xbc, 0xbb, 0xd9, 0x76,
+	0xde, 0xd8, 0xc9, 0x99, 0x99, 0x60, 0xfe, 0x1c, 0x20, 0xe9, 0xa2, 0xd0, 0x4e, 0x9a, 0x48, 0xa6,
+	0x79, 0x33, 0x8c, 0xbc, 0xa9, 0x69, 0xb0, 0xa4, 0x85, 0x49, 0xc0, 0xa6, 0xfa, 0xac, 0x04, 0x6c,
+	0xba, 0xe3, 0x51, 0x60, 0x1a, 0xfa, 0xa3, 0x06, 0x7b, 0xd7, 0x74, 0x11, 0xa8, 0x11, 0xe1, 0xbc,
+	0x5b, 0x17, 0x64, 0x1c, 0xbe, 0xb3, 0xfe, 0x94, 0xcb, 0xbf, 0xd6, 0xe0, 0xce, 0xbc, 0x5a, 0x8f,
+	0x3e, 0x49, 0x63, 0x5f, 0xd3, 0xa5, 0x18, 0x8f, 0xdf, 0x4d, 0x79, 0x8a, 0xc5, 0x97, 0x50, 0xcb,
+	0x16, 0x6a, 0x74, 0x37, 0x2e, 0x62, 0x79, 0xdd, 0x83, 0x71, 0x6f, 0xd6, 0x74, 0x1e, 0x74, 0xb6,
+	0x70, 0x26, 0xd0, 0xb9, 0x05, 0x3c, 0x81, 0xce, 0xaf, 0xb7, 0x29, 0xe8, 0x0e, 0x54, 0xd3, 0xdf,
+	0xaf, 0xd1, 0xee, 0x84, 0x65, 0xfa, 0xcb, 0xba, 0x71, 0x27, 0x7f, 0x72, 0x0a, 0xb4, 0x09, 0xa5,
+	0xa8, 0xe2, 0xa0, 0xed, 0xe4, 0x1b, 0x5e, 0xa6, 0xd6, 0x19, 0xf5, 0xe9, 0x89, 0x6c, 0x98, 0x9d,
+	0x3c, 0xf9, 0x79, 0xa8, 0xe2, 0xd0, 0x5e, 0xa3, 0xef, 0x8d, 0x0e, 0xe5, 0xe3, 0xb7, 0x3d, 0xdf,
+	0x3a, 0x94, 0x86, 0xf2, 0x9f, 0x81, 0x43, 0xcb, 0x53, 0xe3, 0x71, 0xaf, 0x57, 0x14, 0xa2, 0x4f,
+	0xff, 0x17, 0x00, 0x00, 0xff, 0xff, 0x7a, 0xea, 0x94, 0xeb, 0x75, 0x18, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/proto/go/gitalypb/shared.pb.go b/proto/go/gitalypb/shared.pb.go
index 8f6955f0f0..7691d2471c 100644
--- a/proto/go/gitalypb/shared.pb.go
+++ b/proto/go/gitalypb/shared.pb.go
@@ -615,6 +615,64 @@ func (m *ObjectPool) GetRepository() *Repository {
 	return nil
 }
 
+type PaginationParameter struct {
+	// Instructs pagination to start sending results after the provided page
+	// token appears. A page token allows for a generic pattern to uniquely
+	// identify a result or 'page'. Each paginated RPC may interpret a page
+	// token differently.
+	PageToken string `protobuf:"bytes,1,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
+	// When fully consuming the response the client will receive _at most_
+	// `limit` number of resulting objects. Note that the number of response
+	// messages might be much lower, as some response messages already send
+	// multiple objects per message.
+	// When the limit is smaller than 0, it will be normalized to 2147483647
+	// on the server side. When limit is not set, it defaults to 0, and no
+	// results are send in the response.
+	Limit                int32    `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PaginationParameter) Reset()         { *m = PaginationParameter{} }
+func (m *PaginationParameter) String() string { return proto.CompactTextString(m) }
+func (*PaginationParameter) ProtoMessage()    {}
+func (*PaginationParameter) Descriptor() ([]byte, []int) {
+	return fileDescriptor_d8a4e87e678c5ced, []int{8}
+}
+
+func (m *PaginationParameter) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_PaginationParameter.Unmarshal(m, b)
+}
+func (m *PaginationParameter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_PaginationParameter.Marshal(b, m, deterministic)
+}
+func (m *PaginationParameter) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PaginationParameter.Merge(m, src)
+}
+func (m *PaginationParameter) XXX_Size() int {
+	return xxx_messageInfo_PaginationParameter.Size(m)
+}
+func (m *PaginationParameter) XXX_DiscardUnknown() {
+	xxx_messageInfo_PaginationParameter.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PaginationParameter proto.InternalMessageInfo
+
+func (m *PaginationParameter) GetPageToken() string {
+	if m != nil {
+		return m.PageToken
+	}
+	return ""
+}
+
+func (m *PaginationParameter) GetLimit() int32 {
+	if m != nil {
+		return m.Limit
+	}
+	return 0
+}
+
 func init() {
 	proto.RegisterEnum("gitaly.ObjectType", ObjectType_name, ObjectType_value)
 	proto.RegisterEnum("gitaly.SignatureType", SignatureType_name, SignatureType_value)
@@ -626,60 +684,64 @@ func init() {
 	proto.RegisterType((*Tag)(nil), "gitaly.Tag")
 	proto.RegisterType((*User)(nil), "gitaly.User")
 	proto.RegisterType((*ObjectPool)(nil), "gitaly.ObjectPool")
+	proto.RegisterType((*PaginationParameter)(nil), "gitaly.PaginationParameter")
 }
 
 func init() { proto.RegisterFile("shared.proto", fileDescriptor_d8a4e87e678c5ced) }
 
 var fileDescriptor_d8a4e87e678c5ced = []byte{
-	// 797 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x5d, 0x6f, 0x23, 0x35,
-	0x14, 0xdd, 0x99, 0x4c, 0xbe, 0x6e, 0x26, 0x65, 0x30, 0x45, 0x1a, 0x15, 0xad, 0xb6, 0x0c, 0x12,
-	0xaa, 0x56, 0x65, 0x52, 0x05, 0x81, 0x40, 0xe2, 0xa5, 0x59, 0x4a, 0xd5, 0x85, 0x4d, 0xa2, 0x69,
-	0x2a, 0x10, 0x2f, 0x23, 0x27, 0xe3, 0x75, 0x8c, 0x3c, 0xf1, 0xc8, 0x76, 0x56, 0xa4, 0xcf, 0x3c,
-	0xf1, 0xc4, 0x9f, 0xe0, 0x95, 0x9f, 0xc1, 0xef, 0x42, 0xb6, 0x67, 0xb2, 0x59, 0x28, 0x88, 0x7d,
-	0xbb, 0xf7, 0xfa, 0xf8, 0xfa, 0xdc, 0xe3, 0x63, 0x43, 0xa8, 0xd6, 0x58, 0x92, 0x22, 0xad, 0xa4,
-	0xd0, 0x02, 0x75, 0x28, 0xd3, 0x98, 0xef, 0x4e, 0x9e, 0x50, 0x21, 0x28, 0x27, 0x23, 0x5b, 0x5d,
-	0x6e, 0x5f, 0x8e, 0x34, 0x2b, 0x89, 0xd2, 0xb8, 0xac, 0x1c, 0xf0, 0x04, 0x38, 0xdb, 0x68, 0x17,
-	0x27, 0x7f, 0xf8, 0x00, 0x19, 0xa9, 0x84, 0x62, 0x5a, 0xc8, 0x1d, 0xfa, 0x10, 0x42, 0xa5, 0x85,
-	0xc4, 0x94, 0xe4, 0x1b, 0x5c, 0x92, 0xd8, 0x3f, 0xf5, 0xce, 0xfa, 0xd9, 0xa0, 0xae, 0x4d, 0x71,
-	0x49, 0xd0, 0x47, 0x30, 0x94, 0x84, 0x63, 0xcd, 0x5e, 0x91, 0xbc, 0xc2, 0x7a, 0x1d, 0xb7, 0x2c,
-	0x26, 0x6c, 0x8a, 0x73, 0xac, 0xd7, 0xe8, 0x02, 0x8e, 0x29, 0xd3, 0xb9, 0x58, 0xfe, 0x44, 0x56,
-	0x3a, 0x2f, 0x98, 0x24, 0x2b, 0xd3, 0x3f, 0x0e, 0x2c, 0x16, 0x51, 0xa6, 0x67, 0x76, 0xe9, 0xeb,
-	0x66, 0x05, 0x5d, 0xc3, 0xa9, 0xd9, 0x81, 0xb9, 0x26, 0x72, 0x83, 0x35, 0xf9, 0xfb, 0x5e, 0x46,
-	0x54, 0xdc, 0x3e, 0x6d, 0x9d, 0xf5, 0xb3, 0xc7, 0x94, 0xe9, 0xcb, 0x06, 0xf6, 0x66, 0x1b, 0x46,
-	0x94, 0xe1, 0x47, 0x79, 0x2e, 0xf7, 0x33, 0xc5, 0x1d, 0xc7, 0x8f, 0xf2, 0x83, 0x39, 0x3f, 0x86,
-	0x77, 0x28, 0xcf, 0x2b, 0x29, 0xec, 0x19, 0x76, 0x8c, 0x9e, 0x85, 0x0d, 0x29, 0x9f, 0xbb, 0xaa,
-	0x99, 0xe3, 0x79, 0xd0, 0xf3, 0x22, 0xff, 0x79, 0xd0, 0xeb, 0x46, 0xbd, 0x2c, 0x30, 0xb0, 0xe4,
-	0x77, 0x1f, 0xfa, 0xd7, 0x4c, 0x3f, 0x13, 0x65, 0xc9, 0x34, 0x3a, 0x02, 0x9f, 0x15, 0xb1, 0x67,
-	0xb7, 0xfa, 0xac, 0x40, 0x31, 0x74, 0xd5, 0xd6, 0x52, 0xb2, 0xd2, 0x85, 0x59, 0x93, 0x22, 0x04,
-	0xc1, 0x52, 0x14, 0x3b, 0xab, 0x56, 0x98, 0xd9, 0x18, 0x9d, 0x43, 0x07, 0x6f, 0xf5, 0x5a, 0x48,
-	0xab, 0xcb, 0x60, 0x7c, 0x9c, 0xba, 0x2b, 0x4c, 0x5d, 0xf7, 0x4b, 0xbb, 0x96, 0xd5, 0x18, 0x34,
-	0x86, 0xfe, 0xca, 0xd6, 0x35, 0x91, 0x71, 0xfb, 0x3f, 0x36, 0xbc, 0x86, 0xa1, 0xc7, 0x00, 0x15,
-	0x96, 0x64, 0xa3, 0x73, 0x56, 0xa8, 0xb8, 0x63, 0xf5, 0xeb, 0xbb, 0xca, 0x4d, 0xa1, 0xd0, 0x07,
-	0xd0, 0x37, 0x44, 0x72, 0xc5, 0xee, 0x49, 0xdc, 0x3d, 0xf5, 0xce, 0x5a, 0x59, 0xcf, 0x14, 0x6e,
-	0xd9, 0x3d, 0x41, 0x5f, 0xc1, 0x91, 0x62, 0x74, 0x83, 0xf5, 0x56, 0x92, 0x5c, 0xef, 0x2a, 0x62,
-	0x25, 0x3a, 0x1a, 0xbf, 0xdf, 0x1c, 0x7a, 0xdb, 0xac, 0x2e, 0x76, 0x15, 0xc9, 0x86, 0xea, 0x30,
-	0x4d, 0x7e, 0xf1, 0x20, 0x3c, 0x64, 0x65, 0x04, 0xb0, 0x96, 0xf2, 0x9c, 0x00, 0x26, 0x46, 0xc7,
-	0xd0, 0x26, 0x25, 0x66, 0xbc, 0x16, 0xcb, 0x25, 0x28, 0x85, 0xa0, 0xc0, 0x9a, 0x58, 0xa9, 0x06,
-	0xe3, 0x93, 0xd4, 0xf9, 0x39, 0x6d, 0xfc, 0x9c, 0x2e, 0x1a, 0x3f, 0x67, 0x16, 0x87, 0x4e, 0xa0,
-	0x67, 0x2c, 0x7e, 0x2f, 0x36, 0xc4, 0x0a, 0x19, 0x66, 0xfb, 0x3c, 0x49, 0x00, 0xae, 0x7e, 0x66,
-	0xfa, 0x56, 0x63, 0xbd, 0x55, 0xe6, 0xbc, 0x57, 0x98, 0x6f, 0x1d, 0x89, 0x76, 0xe6, 0x92, 0x64,
-	0x01, 0x9d, 0x89, 0xc4, 0x9b, 0xd5, 0xfa, 0x41, 0x8e, 0x9f, 0xc3, 0x50, 0x63, 0x49, 0x89, 0xce,
-	0x9d, 0xac, 0x96, 0xeb, 0x60, 0xfc, 0x6e, 0xa3, 0xc2, 0xde, 0x0c, 0x59, 0xe8, 0x70, 0x2e, 0x4b,
-	0x7e, 0xf5, 0xa1, 0xb5, 0xc0, 0xf4, 0xc1, 0x9e, 0xce, 0x36, 0xfe, 0xde, 0x36, 0xff, 0x38, 0xa3,
-	0xf5, 0xbf, 0xce, 0x30, 0x76, 0x2b, 0x89, 0x52, 0x98, 0x36, 0x83, 0x37, 0xa9, 0x79, 0xc8, 0x75,
-	0xe8, 0x2e, 0xb7, 0x6d, 0x2f, 0x77, 0x50, 0xd7, 0xec, 0xfd, 0x9e, 0x43, 0x47, 0x63, 0x4a, 0x89,
-	0xb4, 0x2f, 0xe4, 0x5f, 0xdd, 0xe7, 0x30, 0x0f, 0xb8, 0xa1, 0xfb, 0x16, 0x6e, 0x78, 0x09, 0xc1,
-	0x9d, 0x22, 0x12, 0xbd, 0x07, 0x6d, 0xca, 0xf3, 0xfd, 0x93, 0x09, 0x28, 0xbf, 0x29, 0xf6, 0x0a,
-	0xf9, 0x0f, 0x39, 0xa3, 0x75, 0xe8, 0x8c, 0x27, 0x30, 0xa0, 0x3c, 0xdf, 0x2a, 0xf3, 0xf6, 0x4b,
-	0x52, 0xff, 0x26, 0x40, 0xf9, 0x5d, 0x5d, 0x49, 0xbe, 0x01, 0x70, 0x3f, 0xc2, 0x5c, 0x08, 0x8e,
-	0xbe, 0x00, 0x38, 0xf8, 0x07, 0x3c, 0x3b, 0x25, 0x6a, 0xf8, 0xbe, 0xfe, 0x0d, 0x26, 0xc1, 0x6f,
-	0x7f, 0x9e, 0x7b, 0xd9, 0x01, 0xf6, 0xe9, 0xa4, 0xe9, 0x63, 0xd8, 0xa3, 0x01, 0x74, 0xef, 0xa6,
-	0xdf, 0x4e, 0x67, 0xdf, 0x4f, 0xa3, 0x47, 0x08, 0xa0, 0xf3, 0x6c, 0xf6, 0xe2, 0xc5, 0xcd, 0x22,
-	0xf2, 0x50, 0x0f, 0x82, 0xc9, 0x77, 0xb3, 0x49, 0xe4, 0x9b, 0x68, 0x91, 0x5d, 0x5d, 0x45, 0x2d,
-	0xd4, 0x85, 0xd6, 0xe2, 0xf2, 0x3a, 0x0a, 0x9e, 0x9e, 0xc3, 0xf0, 0x0d, 0x4d, 0x0c, 0x66, 0x3a,
-	0x9b, 0x5e, 0x45, 0x8f, 0x0c, 0x66, 0x7e, 0x3d, 0x77, 0x0d, 0x7e, 0xf8, 0xec, 0xe2, 0xcb, 0xc8,
-	0x9f, 0x5c, 0xfc, 0x68, 0x88, 0x71, 0xbc, 0x4c, 0x57, 0xa2, 0x1c, 0xb9, 0xf0, 0x13, 0x21, 0xe9,
-	0xc8, 0xd1, 0x75, 0xbf, 0xf9, 0x88, 0x8a, 0x3a, 0xaf, 0x96, 0xcb, 0x8e, 0x2d, 0x7d, 0xfa, 0x57,
-	0x00, 0x00, 0x00, 0xff, 0xff, 0x11, 0x19, 0x40, 0xb8, 0x06, 0x06, 0x00, 0x00,
+	// 835 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0x4f, 0x8f, 0xe3, 0x34,
+	0x1c, 0xdd, 0xa4, 0xe9, 0xbf, 0x5f, 0xdb, 0x21, 0x78, 0x07, 0x29, 0x1a, 0xb4, 0xda, 0x21, 0x48,
+	0x68, 0xb4, 0x1a, 0xda, 0x51, 0x11, 0x08, 0x24, 0x2e, 0xd3, 0x65, 0x18, 0xcd, 0xc0, 0xb6, 0x55,
+	0xa6, 0x23, 0x10, 0x97, 0xc8, 0x6d, 0xbc, 0xae, 0xc1, 0x89, 0x23, 0xdb, 0x5d, 0xd1, 0x39, 0x73,
+	0xe2, 0xc4, 0x97, 0xe0, 0xca, 0xc7, 0xe0, 0x73, 0x21, 0xdb, 0x49, 0xb7, 0x0b, 0x05, 0xb1, 0x37,
+	0xff, 0x5e, 0x9e, 0xed, 0xf7, 0x7b, 0x7e, 0x76, 0xa0, 0xaf, 0xd6, 0x58, 0x92, 0x6c, 0x58, 0x4a,
+	0xa1, 0x05, 0x6a, 0x51, 0xa6, 0x31, 0xdf, 0x9e, 0x3c, 0xa5, 0x42, 0x50, 0x4e, 0x46, 0x16, 0x5d,
+	0x6e, 0x5e, 0x8e, 0x34, 0xcb, 0x89, 0xd2, 0x38, 0x2f, 0x1d, 0xf1, 0x04, 0x38, 0x2b, 0xb4, 0x1b,
+	0xc7, 0x7f, 0xf8, 0x00, 0x09, 0x29, 0x85, 0x62, 0x5a, 0xc8, 0x2d, 0xfa, 0x00, 0xfa, 0x4a, 0x0b,
+	0x89, 0x29, 0x49, 0x0b, 0x9c, 0x93, 0xc8, 0x3f, 0xf5, 0xce, 0xba, 0x49, 0xaf, 0xc2, 0xa6, 0x38,
+	0x27, 0xe8, 0x43, 0x18, 0x48, 0xc2, 0xb1, 0x66, 0xaf, 0x48, 0x5a, 0x62, 0xbd, 0x8e, 0x1a, 0x96,
+	0xd3, 0xaf, 0xc1, 0x39, 0xd6, 0x6b, 0x74, 0x01, 0xc7, 0x94, 0xe9, 0x54, 0x2c, 0x7f, 0x24, 0x2b,
+	0x9d, 0x66, 0x4c, 0x92, 0x95, 0x59, 0x3f, 0x0a, 0x2c, 0x17, 0x51, 0xa6, 0x67, 0xf6, 0xd3, 0x57,
+	0xf5, 0x17, 0x74, 0x0d, 0xa7, 0x66, 0x06, 0xe6, 0x9a, 0xc8, 0x02, 0x6b, 0xf2, 0xf7, 0xb9, 0x8c,
+	0xa8, 0xa8, 0x79, 0xda, 0x38, 0xeb, 0x26, 0x4f, 0x28, 0xd3, 0x97, 0x35, 0xed, 0xcd, 0x65, 0x18,
+	0x51, 0x46, 0x1f, 0xe5, 0xa9, 0xdc, 0xf5, 0x14, 0xb5, 0x9c, 0x3e, 0xca, 0xf7, 0xfa, 0xfc, 0x08,
+	0xde, 0xa1, 0x3c, 0x2d, 0xa5, 0xb0, 0x7b, 0xd8, 0x36, 0x3a, 0x96, 0x36, 0xa0, 0x7c, 0xee, 0x50,
+	0xd3, 0xc7, 0x6d, 0xd0, 0xf1, 0x42, 0xff, 0x36, 0xe8, 0xb4, 0xc3, 0x4e, 0x12, 0x18, 0x5a, 0xfc,
+	0xbb, 0x0f, 0xdd, 0x6b, 0xa6, 0x9f, 0x8b, 0x3c, 0x67, 0x1a, 0x1d, 0x81, 0xcf, 0xb2, 0xc8, 0xb3,
+	0x53, 0x7d, 0x96, 0xa1, 0x08, 0xda, 0x6a, 0x63, 0x25, 0x59, 0xeb, 0xfa, 0x49, 0x5d, 0x22, 0x04,
+	0xc1, 0x52, 0x64, 0x5b, 0xeb, 0x56, 0x3f, 0xb1, 0x63, 0x74, 0x0e, 0x2d, 0xbc, 0xd1, 0x6b, 0x21,
+	0xad, 0x2f, 0xbd, 0xf1, 0xf1, 0xd0, 0x1d, 0xe1, 0xd0, 0xad, 0x7e, 0x69, 0xbf, 0x25, 0x15, 0x07,
+	0x8d, 0xa1, 0xbb, 0xb2, 0xb8, 0x26, 0x32, 0x6a, 0xfe, 0xc7, 0x84, 0xd7, 0x34, 0xf4, 0x04, 0xa0,
+	0xc4, 0x92, 0x14, 0x3a, 0x65, 0x99, 0x8a, 0x5a, 0xd6, 0xbf, 0xae, 0x43, 0x6e, 0x32, 0x85, 0xde,
+	0x87, 0xae, 0x11, 0x92, 0x2a, 0xf6, 0x40, 0xa2, 0xf6, 0xa9, 0x77, 0xd6, 0x48, 0x3a, 0x06, 0xb8,
+	0x63, 0x0f, 0x04, 0x7d, 0x09, 0x47, 0x8a, 0xd1, 0x02, 0xeb, 0x8d, 0x24, 0xa9, 0xde, 0x96, 0xc4,
+	0x5a, 0x74, 0x34, 0x7e, 0xaf, 0xde, 0xf4, 0xae, 0xfe, 0xba, 0xd8, 0x96, 0x24, 0x19, 0xa8, 0xfd,
+	0x32, 0xfe, 0xc5, 0x83, 0xfe, 0xbe, 0x2a, 0x63, 0x80, 0x8d, 0x94, 0xe7, 0x0c, 0x30, 0x63, 0x74,
+	0x0c, 0x4d, 0x92, 0x63, 0xc6, 0x2b, 0xb3, 0x5c, 0x81, 0x86, 0x10, 0x64, 0x58, 0x13, 0x6b, 0x55,
+	0x6f, 0x7c, 0x32, 0x74, 0x79, 0x1e, 0xd6, 0x79, 0x1e, 0x2e, 0xea, 0x3c, 0x27, 0x96, 0x87, 0x4e,
+	0xa0, 0x63, 0x22, 0xfe, 0x20, 0x0a, 0x62, 0x8d, 0xec, 0x27, 0xbb, 0x3a, 0x8e, 0x01, 0xae, 0x7e,
+	0x66, 0xfa, 0x4e, 0x63, 0xbd, 0x51, 0x66, 0xbf, 0x57, 0x98, 0x6f, 0x9c, 0x88, 0x66, 0xe2, 0x8a,
+	0x78, 0x01, 0xad, 0x89, 0xc4, 0xc5, 0x6a, 0x7d, 0x50, 0xe3, 0x67, 0x30, 0xd0, 0x58, 0x52, 0xa2,
+	0x53, 0x67, 0xab, 0xd5, 0xda, 0x1b, 0xbf, 0x5b, 0xbb, 0xb0, 0x0b, 0x43, 0xd2, 0x77, 0x3c, 0x57,
+	0xc5, 0xbf, 0xfa, 0xd0, 0x58, 0x60, 0x7a, 0x70, 0x4d, 0x17, 0x1b, 0x7f, 0x17, 0x9b, 0x7f, 0xec,
+	0xd1, 0xf8, 0x5f, 0x7b, 0x98, 0xb8, 0xe5, 0x44, 0x29, 0x4c, 0xeb, 0xc6, 0xeb, 0xd2, 0x5c, 0xe4,
+	0x6a, 0xe8, 0x0e, 0xb7, 0x69, 0x0f, 0xb7, 0x57, 0x61, 0xf6, 0x7c, 0xcf, 0xa1, 0xa5, 0x31, 0xa5,
+	0x44, 0xda, 0x1b, 0xf2, 0xaf, 0xe9, 0x73, 0x9c, 0x03, 0x69, 0x68, 0xbf, 0x45, 0x1a, 0x5e, 0x42,
+	0x70, 0xaf, 0x88, 0x44, 0x8f, 0xa1, 0x49, 0x79, 0xba, 0xbb, 0x32, 0x01, 0xe5, 0x37, 0xd9, 0xce,
+	0x21, 0xff, 0x50, 0x32, 0x1a, 0xfb, 0xc9, 0x78, 0x0a, 0x3d, 0xca, 0xd3, 0x8d, 0x32, 0x77, 0x3f,
+	0x27, 0xd5, 0x6b, 0x02, 0x94, 0xdf, 0x57, 0x48, 0xfc, 0x35, 0x80, 0x7b, 0x11, 0xe6, 0x42, 0x70,
+	0xf4, 0x39, 0xc0, 0xde, 0x3b, 0xe0, 0xd9, 0x2e, 0x51, 0xad, 0xf7, 0xf5, 0x6b, 0x30, 0x09, 0x7e,
+	0xfb, 0xf3, 0xdc, 0x4b, 0xf6, 0xb8, 0xf1, 0x2d, 0x3c, 0x9e, 0x63, 0xca, 0x0a, 0xac, 0x99, 0x28,
+	0xe6, 0x58, 0xe2, 0x9c, 0xec, 0xae, 0x13, 0x25, 0xa9, 0x16, 0x3f, 0x91, 0xa2, 0xea, 0xa1, 0x6b,
+	0x90, 0x85, 0x01, 0x8c, 0x68, 0xce, 0xea, 0x88, 0x34, 0x13, 0x57, 0x3c, 0x9b, 0xd4, 0x9a, 0x8c,
+	0x13, 0xa8, 0x07, 0xed, 0xfb, 0xe9, 0x37, 0xd3, 0xd9, 0x77, 0xd3, 0xf0, 0x11, 0x02, 0x68, 0x3d,
+	0x9f, 0xbd, 0x78, 0x71, 0xb3, 0x08, 0x3d, 0xd4, 0x81, 0x60, 0xf2, 0xed, 0x6c, 0x12, 0xfa, 0x66,
+	0xb4, 0x48, 0xae, 0xae, 0xc2, 0x06, 0x6a, 0x43, 0x63, 0x71, 0x79, 0x1d, 0x06, 0xcf, 0xce, 0x61,
+	0xf0, 0x86, 0xbf, 0x86, 0x33, 0x9d, 0x4d, 0xaf, 0xc2, 0x47, 0x86, 0x33, 0xbf, 0x9e, 0xbb, 0x05,
+	0xbe, 0xff, 0xf4, 0xe2, 0x8b, 0xd0, 0x9f, 0x5c, 0xfc, 0x60, 0x9a, 0xe4, 0x78, 0x39, 0x5c, 0x89,
+	0x7c, 0xe4, 0x86, 0x1f, 0x0b, 0x49, 0x47, 0xae, 0x75, 0xf7, 0x67, 0x18, 0x51, 0x51, 0xd5, 0xe5,
+	0x72, 0xd9, 0xb2, 0xd0, 0x27, 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0x7d, 0xe3, 0xe3, 0xc9, 0x52,
+	0x06, 0x00, 0x00,
 }
diff --git a/proto/ref.proto b/proto/ref.proto
index 8e99267fa2..1943b83c43 100644
--- a/proto/ref.proto
+++ b/proto/ref.proto
@@ -167,6 +167,11 @@ message FindLocalBranchesRequest {
     UPDATED_DESC = 2;
   }
   SortBy sort_by = 2;
+  // The page token is the branch name, with the `refs/heads/` prefix, for
+  // example "refs/heads/master". After the first branch name is encountered
+  // which lexicographically exceeds the page token, it will be the first result
+  // send as part of the response.
+  PaginationParameter pagination_params = 3;
 }
 
 message FindLocalBranchesResponse {
diff --git a/proto/shared.proto b/proto/shared.proto
index 59076a4418..9f843ee68b 100644
--- a/proto/shared.proto
+++ b/proto/shared.proto
@@ -103,3 +103,19 @@ message User {
 message ObjectPool {
   Repository repository = 1 [(gitaly.repository)=true];
 }
+
+message PaginationParameter {
+	// Instructs pagination to start sending results after the provided page
+	// token appears. A page token allows for a generic pattern to uniquely
+	// identify a result or 'page'. Each paginated RPC may interpret a page
+	// token differently.
+	string page_token = 1;
+	// When fully consuming the response the client will receive _at most_
+	// `limit` number of resulting objects. Note that the number of response
+	// messages might be much lower, as some response messages already send
+	// multiple objects per message.
+	// When the limit is smaller than 0, it will be normalized to 2147483647
+	// on the server side. When limit is not set, it defaults to 0, and no
+	// results are send in the response.
+	int32 limit = 2;
+}
diff --git a/ruby/proto/gitaly/ref_pb.rb b/ruby/proto/gitaly/ref_pb.rb
index 21521ed29d..adac1a6dfb 100644
--- a/ruby/proto/gitaly/ref_pb.rb
+++ b/ruby/proto/gitaly/ref_pb.rb
@@ -45,6 +45,7 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
   add_message "gitaly.FindLocalBranchesRequest" do
     optional :repository, :message, 1, "gitaly.Repository"
     optional :sort_by, :enum, 2, "gitaly.FindLocalBranchesRequest.SortBy"
+    optional :pagination_params, :message, 3, "gitaly.PaginationParameter"
   end
   add_enum "gitaly.FindLocalBranchesRequest.SortBy" do
     value :NAME, 0
diff --git a/ruby/proto/gitaly/shared_pb.rb b/ruby/proto/gitaly/shared_pb.rb
index 00c318cd2f..2581101d7d 100644
--- a/ruby/proto/gitaly/shared_pb.rb
+++ b/ruby/proto/gitaly/shared_pb.rb
@@ -55,6 +55,10 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
   add_message "gitaly.ObjectPool" do
     optional :repository, :message, 1, "gitaly.Repository"
   end
+  add_message "gitaly.PaginationParameter" do
+    optional :page_token, :string, 1
+    optional :limit, :int32, 2
+  end
   add_enum "gitaly.ObjectType" do
     value :UNKNOWN, 0
     value :COMMIT, 1
@@ -78,6 +82,7 @@ module Gitaly
   Tag = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.Tag").msgclass
   User = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.User").msgclass
   ObjectPool = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.ObjectPool").msgclass
+  PaginationParameter = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.PaginationParameter").msgclass
   ObjectType = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.ObjectType").enummodule
   SignatureType = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.SignatureType").enummodule
 end
-- 
GitLab