diff --git a/internal/command/command.go b/internal/command/command.go
index ae374f3a824b0c07872f7461f0d388cc6661bdf6..ec3236011247cba8975c559f82b8078aef8019fb 100644
--- a/internal/command/command.go
+++ b/internal/command/command.go
@@ -63,6 +63,10 @@ const (
 	StderrBufferSize = 4096
 )
 
+type Cmd interface {
+	Wait() error
+}
+
 // Command encapsulates a running exec.Cmd. The embedded exec.Cmd is
 // terminated and reaped automatically when the context.Context that
 // created it is canceled.
diff --git a/internal/git/repository/repository.go b/internal/git/repository/repository.go
index 3a200d7a8ea8e33f715480d4812c3e9855bdef7e..c7b94184caf80f1bca3d26b12526b32434236753 100644
--- a/internal/git/repository/repository.go
+++ b/internal/git/repository/repository.go
@@ -1,5 +1,16 @@
 package repository
 
+import (
+	"errors"
+	"os/exec"
+	"sync"
+	"time"
+
+	"github.com/sirupsen/logrus"
+	"gitlab.com/gitlab-org/gitaly/internal/log"
+	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
+)
+
 // GitRepo supplies an interface for executing `git.Command`s
 type GitRepo interface {
 	GetStorageName() string
@@ -7,3 +18,210 @@ type GitRepo interface {
 	GetGitObjectDirectory() string
 	GetGitAlternateObjectDirectories() []string
 }
+
+func NewTransactionManager() *TransactionManager {
+	return &TransactionManager{
+		transactions: make(map[string]*Transaction),
+		repositories: make(map[string]*sync.Mutex),
+		log:          log.Default(),
+	}
+}
+
+type TransactionManager struct {
+	txMutex, repoMutex sync.RWMutex
+	transactions       map[string]*Transaction
+	repositories       map[string]*sync.Mutex
+	log                *logrus.Entry
+}
+
+func (t *TransactionManager) NewTransaction(transactionID string, repo *gitalypb.Repository) {
+	logrus.WithField("transaction_id", transactionID).Info("creating new transaction")
+	tx := Transaction{
+		repo:     repo,
+		commitCh: make(chan error),
+	}
+
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
+	t.transactions[transactionID] = &tx
+
+	t.repoMutex.Lock()
+	_, ok := t.repositories[tx.repo.GetRelativePath()]
+	if !ok {
+		t.repositories[tx.repo.GetRelativePath()] = &sync.Mutex{}
+	}
+	t.repositories[tx.repo.GetRelativePath()].Lock()
+	t.repoMutex.Unlock()
+}
+
+func (t *TransactionManager) Begin(transactionID string) {
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
+
+	tx, ok := t.transactions[transactionID]
+	if !ok {
+		return
+	}
+
+	tx.inProgress = true
+
+	go func() {
+		<-time.NewTimer(2 * time.Second).C
+		t.txMutex.Lock()
+
+		tx, ok := t.transactions[transactionID]
+		if !ok {
+			t.txMutex.Unlock()
+			return
+		}
+		if tx.prepared {
+			t.log.WithField("transaction_id", transactionID).Info("transaction has already been prepared")
+			t.txMutex.Unlock()
+			return
+		}
+
+		t.txMutex.Unlock()
+		t.log.WithField("transaction_id", transactionID).Info("transaction has not been prepared and is timing out")
+		t.Release(transactionID)
+	}()
+}
+
+func (t *TransactionManager) PreCommit(transactionID string, c *exec.Cmd) {
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
+
+	tx, ok := t.transactions[transactionID]
+	if !ok {
+		return
+	}
+
+	go func() {
+		tx.PrepareCommitAndWait(c, 2*time.Second)
+		t.Release(transactionID)
+	}()
+}
+
+func (t *TransactionManager) SetRollback(transactionID string, rollback *exec.Cmd) {
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
+	tx, ok := t.transactions[transactionID]
+	if !ok {
+		return
+	}
+
+	tx.rollback = rollback
+}
+
+func (t *TransactionManager) Commit(transactionID string) error {
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
+
+	tx, ok := t.transactions[transactionID]
+	if !ok {
+		return errors.New("request_id not found")
+	}
+
+	t.log.WithField("transaction_id", transactionID).Info("commited")
+	return tx.Commit()
+}
+
+func (t *TransactionManager) Release(transactionID string) error {
+	t.log.WithField("transaction_id", transactionID).Info("unlocking")
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
+
+	tx, ok := t.transactions[transactionID]
+	if !ok {
+		return errors.New("request_id not found")
+	}
+
+	if !tx.inProgress {
+		t.repoMutex.Lock()
+		defer t.repoMutex.Unlock()
+
+		repoLock, ok := t.repositories[tx.repo.GetRelativePath()]
+		if !ok {
+			return nil
+		}
+		repoLock.Unlock()
+
+		delete(t.transactions, transactionID)
+		t.log.WithField("transaction_id", transactionID).Info("unlocked")
+	}
+
+	return nil
+}
+
+func (t *TransactionManager) Rollback(transactionID string) error {
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
+
+	tx, ok := t.transactions[transactionID]
+	if !ok {
+		return errors.New("request_id not found")
+	}
+
+	if err := tx.rollback.Run(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (t *TransactionManager) TransactionStarted(transactionID string) bool {
+	t.txMutex.Lock()
+	defer t.txMutex.Unlock()
+
+	_, ok := t.transactions[transactionID]
+
+	return ok
+}
+
+func (t *Transaction) PrepareCommitAndWait(c *exec.Cmd, d time.Duration) {
+	logrus.WithError(t.commitErr).Info("precommit started")
+	t.prepared = true
+	t.commit = c
+
+	<-time.NewTimer(d).C
+	if !t.inProgress {
+		return
+	}
+	logrus.Info("timer went off...i'm doin it!")
+	t.Commit()
+
+	logrus.WithError(t.commitErr).Info("precommit completed")
+}
+
+func (t *Transaction) Commit() error {
+	if t.commitErr != nil {
+		return t.commitErr
+	}
+	if !t.inProgress {
+		return nil
+	}
+
+	defer func() {
+		t.inProgress = false
+	}()
+
+	if t.commitErr = t.commit.Start(); t.commitErr != nil {
+		return t.commitErr
+	}
+
+	if t.commitErr = t.commit.Wait(); t.commitErr != nil {
+		return t.commitErr
+	}
+
+	logrus.WithError(t.commitErr).WithField("args", t.commit.Args).Info("Finished Commit")
+
+	return nil
+}
+
+type Transaction struct {
+	repo                 GitRepo
+	commit               *exec.Cmd
+	rollback             *exec.Cmd
+	commitErr            error
+	commitCh             chan error
+	inProgress, prepared bool
+}
diff --git a/internal/middleware/repositoryhandler/transactions.go b/internal/middleware/repositoryhandler/transactions.go
new file mode 100644
index 0000000000000000000000000000000000000000..273d7466c73c27437c8d446a7723d19cf1e245f0
--- /dev/null
+++ b/internal/middleware/repositoryhandler/transactions.go
@@ -0,0 +1,140 @@
+package repositoryhandler
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"reflect"
+
+	"github.com/google/uuid"
+	"github.com/sirupsen/logrus"
+	"gitlab.com/gitlab-org/gitaly/internal/git/repository"
+	"gitlab.com/gitlab-org/gitaly/internal/praefect/protoregistry"
+	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
+)
+
+type RepositoryRequest interface {
+	GetRepository() *gitalypb.Repository
+}
+
+func RepositoryTransactionUnaryInterceptor(transactions *repository.TransactionManager, registry *protoregistry.Registry) grpc.UnaryServerInterceptor {
+	return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
+		mi, err := registry.LookupMethod(info.FullMethod)
+		if err != nil {
+			return handler(ctx, req)
+		}
+
+		if mi.Scope == protoregistry.ScopeRepository && mi.Operation == protoregistry.OpMutator {
+			var transactionID string
+
+			md, ok := metadata.FromIncomingContext(ctx)
+			if ok && len(md.Get("transaction_id")) > 0 {
+				transactionID = md.Get("transaction_id")[0]
+			} else {
+				transactionID = uuid.New().String()
+			}
+
+			if !transactions.TransactionStarted(transactionID) {
+				repoReq, ok := req.(RepositoryRequest)
+				if !ok {
+					return nil, errors.New("not a repository request")
+				}
+				if repoReq.GetRepository() != nil {
+					logrus.WithField("repository", repoReq.GetRepository()).Info("trying to start new transaction")
+					transactions.NewTransaction(transactionID, repoReq.GetRepository())
+					logrus.WithField("repository", repoReq.GetRepository()).Info("started new transaction")
+				}
+			}
+
+			defer transactions.Release(transactionID)
+
+			md.Set("transaction_id", transactionID)
+			ctx = metadata.NewIncomingContext(ctx, md)
+
+			grpc.SetTrailer(ctx, metadata.New(map[string]string{"transaction_id": transactionID}))
+		}
+
+		return handler(ctx, req)
+	}
+}
+
+func NewTransactionServerStream(ss grpc.ServerStream, methodInfo protoregistry.MethodInfo, transactions *repository.TransactionManager, transactionID string) TransactionServerStream {
+	return TransactionServerStream{
+		transactionID: transactionID,
+		ss:            ss,
+		mi:            methodInfo,
+		transactions:  transactions,
+	}
+}
+
+type TransactionServerStream struct {
+	transactionID string
+	ss            grpc.ServerStream
+	mi            protoregistry.MethodInfo
+	transactions  *repository.TransactionManager
+}
+
+func (t TransactionServerStream) SetHeader(m metadata.MD) error {
+	return t.ss.SetHeader(m)
+}
+
+func (t TransactionServerStream) SendHeader(m metadata.MD) error {
+	return t.ss.SendHeader(m)
+}
+
+func (t TransactionServerStream) SetTrailer(m metadata.MD) {
+	t.ss.SetTrailer(m)
+}
+
+func (t TransactionServerStream) Context() context.Context {
+	return t.ss.Context()
+}
+
+func (t TransactionServerStream) SendMsg(m interface{}) error {
+	return t.ss.SendMsg(m)
+}
+
+func (t TransactionServerStream) RecvMsg(m interface{}) error {
+	if !t.transactions.TransactionStarted(t.transactionID) {
+		fmt.Printf("Receiving Message: type=%s\n", reflect.TypeOf(m).String())
+		repoReq, ok := m.(RepositoryRequest)
+		if ok && repoReq.GetRepository() != nil {
+			logrus.WithField("repository", repoReq.GetRepository()).Info("trying to start new transaction")
+			t.transactions.NewTransaction(t.transactionID, repoReq.GetRepository())
+			logrus.WithField("repository", repoReq.GetRepository()).Info("started new transaction")
+		}
+	}
+
+	t.ss.SetTrailer(metadata.Pairs("transaction_id", t.transactionID))
+
+	return t.ss.RecvMsg(m)
+}
+
+// StreamInterceptor returns a Stream Interceptor
+func RepositoryTransactionStreamInterceptor(transactions *repository.TransactionManager, registry *protoregistry.Registry) grpc.StreamServerInterceptor {
+	return func(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
+		mi, err := registry.LookupMethod(info.FullMethod)
+		if err != nil {
+			return handler(srv, stream)
+		}
+
+		if mi.Scope == protoregistry.ScopeRepository && mi.Operation == protoregistry.OpMutator {
+			var transactionID string
+
+			md, ok := metadata.FromIncomingContext(stream.Context())
+			if ok && len(md.Get("transaction_id")) > 0 {
+				transactionID = md.Get("transaction_id")[0]
+			} else {
+				transactionID = uuid.New().String()
+			}
+
+			defer transactions.Release(transactionID)
+
+			return handler(srv, NewTransactionServerStream(stream, mi, transactions, transactionID))
+		}
+
+		return handler(srv, stream)
+	}
+}
diff --git a/internal/praefect/coordinator.go b/internal/praefect/coordinator.go
index 45b0dd841a0183de37a9ad9d3b47877be6cd2e73..fd32185454a1aae873f85b8190e619f98dc3e238 100644
--- a/internal/praefect/coordinator.go
+++ b/internal/praefect/coordinator.go
@@ -2,6 +2,7 @@ package praefect
 
 import (
 	"context"
+	"errors"
 	"os"
 	"os/signal"
 	"sync"
@@ -10,13 +11,16 @@ import (
 	"github.com/golang/protobuf/proto"
 	"github.com/golang/protobuf/protoc-gen-go/descriptor"
 	"github.com/sirupsen/logrus"
+	"gitlab.com/gitlab-org/gitaly/internal/helper"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/config"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/datastore"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/grpc-proxy/proxy"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/nodes"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/protoregistry"
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
+	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
 )
 
@@ -34,8 +38,9 @@ type Coordinator struct {
 
 	datastore datastore.Datastore
 
-	registry *protoregistry.Registry
-	conf     config.Config
+	registry   *protoregistry.Registry
+	conf       config.Config
+	replicator Replicator
 }
 
 // NewCoordinator returns a new Coordinator that utilizes the provided logger
@@ -52,6 +57,10 @@ func NewCoordinator(l *logrus.Entry, ds datastore.Datastore, nodeMgr nodes.Manag
 	}
 }
 
+func (c *Coordinator) SetReplicator(replicator Replicator) {
+	c.replicator = replicator
+}
+
 // RegisterProtos allows coordinator to register new protos on the fly
 func (c *Coordinator) RegisterProtos(protos ...*descriptor.FileDescriptorProto) error {
 	return c.registry.RegisterFiles(protos...)
@@ -109,7 +118,7 @@ func (c *Coordinator) directRepositoryScopedMessage(ctx context.Context, mi prot
 func (c *Coordinator) streamDirector(ctx context.Context, fullMethodName string, peeker proxy.StreamModifier) (*proxy.StreamParameters, error) {
 	// For phase 1, we need to route messages based on the storage location
 	// to the appropriate Gitaly node.
-	c.log.Debugf("Stream director received method %s", fullMethodName)
+	c.log.Infof("Stream director received method %s", fullMethodName)
 
 	c.failoverMutex.RLock()
 	defer c.failoverMutex.RUnlock()
@@ -144,6 +153,134 @@ func (c *Coordinator) streamDirector(ctx context.Context, fullMethodName string,
 	return proxy.NewStreamParameters(ctx, primary.GetConnection(), func() {}, nil), nil
 }
 
+func (c *Coordinator) HandleWriteRef(srv interface{}, serverStream grpc.ServerStream) error {
+	var writeRefReq gitalypb.WriteRefRequest
+
+	if err := serverStream.RecvMsg(&writeRefReq); err != nil {
+		return err
+	}
+
+	shard, err := c.nodeMgr.GetShard(writeRefReq.GetRepository().GetStorageName())
+	if err != nil {
+		return err
+	}
+
+	primary, err := shard.GetPrimary()
+	if err != nil {
+		return err
+	}
+
+	secondaries, err := shard.GetSecondaries()
+	if err != nil {
+		return err
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	var errs []error
+	transactionIDs := make(map[string]nodes.Node)
+
+	c.log.Info("about to vote")
+	// vote
+	for _, node := range append(secondaries, primary) {
+		client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
+		targetRepo := &gitalypb.Repository{
+			StorageName:  node.GetStorage(),
+			RelativePath: writeRefReq.GetRepository().GetRelativePath(),
+		}
+		var trailer metadata.MD
+
+		if _, err := client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_step", "vote"), &gitalypb.WriteRefTxRequest{
+			Repository:  targetRepo,
+			Ref:         writeRefReq.Ref,
+			Revision:    writeRefReq.Revision,
+			OldRevision: writeRefReq.OldRevision,
+			Force:       writeRefReq.Force,
+		}, grpc.Trailer(&trailer)); err != nil {
+			errs = append(errs, err)
+			continue
+		}
+
+		if len(trailer.Get("transaction_id")) == 0 {
+			return errors.New("transaction id not found")
+		}
+
+		transactionID := trailer.Get("transaction_id")[0]
+		transactionIDs[transactionID] = node
+	}
+
+	if len(errs) > 0 {
+		return errors.New("votes failed")
+	}
+
+	c.log.Info("about to precommit")
+
+	// PreCommit
+	for transactionID, node := range transactionIDs {
+		client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
+		targetRepo := &gitalypb.Repository{
+			StorageName:  node.GetStorage(),
+			RelativePath: writeRefReq.GetRepository().GetRelativePath(),
+		}
+
+		if _, err := client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_step", "precommit", "transaction_id", transactionID), &gitalypb.WriteRefTxRequest{
+			Repository:  targetRepo,
+			Ref:         writeRefReq.Ref,
+			Revision:    writeRefReq.Revision,
+			OldRevision: writeRefReq.OldRevision,
+			Force:       writeRefReq.Force,
+		}); err != nil {
+			errs = append(errs, err)
+		}
+	}
+
+	c.log.Info("about to commit")
+	// Commit
+	if len(errs) == 0 {
+		for transactionID, node := range transactionIDs {
+			client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
+			if _, err = client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_step", "commit", "transaction_id", transactionID), &gitalypb.WriteRefTxRequest{}); err != nil {
+				if node == primary {
+					return errors.New("primary write failed")
+				}
+
+				injectedCtx, err := helper.InjectGitalyServers(metadata.AppendToOutgoingContext(ctx, "transaction_step", "recover", "transaction_id", transactionID), primary.GetStorage(), primary.GetAddress(), primary.GetToken())
+				if err != nil {
+					return err
+				}
+				client.ReplicateRepository(injectedCtx, &gitalypb.ReplicateRepositoryRequest{
+					Repository: &gitalypb.Repository{
+						StorageName:  node.GetStorage(),
+						RelativePath: writeRefReq.GetRepository().GetRelativePath(),
+					},
+					Source: &gitalypb.Repository{
+						StorageName:  primary.GetStorage(),
+						RelativePath: writeRefReq.GetRepository().GetRelativePath(),
+					},
+				})
+			}
+		}
+	}
+	/*
+
+		if len(errs) == 0 {
+			return nil
+		}
+
+		c.log.Info("about to rollback")
+		// rollback
+		for _, node := range transactionIDs {
+			client := gitalypb.NewRepositoryServiceClient(node.GetConnection())
+			if _, err = client.WriteRefTx(metadata.AppendToOutgoingContext(ctx, "transaction_step", "rollback"), &gitalypb.WriteRefTxRequest{}); err != nil {
+				return err
+			}
+		}
+
+	*/
+	return nil
+}
+
 func (c *Coordinator) rewriteStorageForRepositoryMessage(mi protoregistry.MethodInfo, m proto.Message, peeker proxy.StreamModifier, primaryStorage string) error {
 	targetRepo, err := mi.TargetRepo(m)
 	if err != nil {
diff --git a/internal/praefect/grpc-proxy/proxy/handler.go b/internal/praefect/grpc-proxy/proxy/handler.go
index 0b8c901f7dea7ee620394456a22cd01f5f49ebf7..70ec007d7b69eedba6676c5a951864ecc2d8860d 100644
--- a/internal/praefect/grpc-proxy/proxy/handler.go
+++ b/internal/praefect/grpc-proxy/proxy/handler.go
@@ -27,6 +27,23 @@ var (
 // The behaviour is the same as if you were registering a handler method, e.g. from a codegenerated pb.go file.
 //
 // This can *only* be used if the `server` also uses grpcproxy.CodecForServer() ServerOption.
+func RegisterMutator(server *grpc.Server, streamer grpc.StreamHandler, serviceName string, methodNames ...string) {
+	fakeDesc := &grpc.ServiceDesc{
+		ServiceName: serviceName,
+		HandlerType: (*interface{})(nil),
+	}
+	for _, m := range methodNames {
+		streamDesc := grpc.StreamDesc{
+			StreamName:    m,
+			Handler:       streamer,
+			ServerStreams: true,
+			ClientStreams: true,
+		}
+		fakeDesc.Streams = append(fakeDesc.Streams, streamDesc)
+	}
+	server.RegisterService(fakeDesc, streamer)
+}
+
 func RegisterService(server *grpc.Server, director StreamDirector, serviceName string, methodNames ...string) {
 	streamer := &handler{director}
 	fakeDesc := &grpc.ServiceDesc{
diff --git a/internal/praefect/helper_test.go b/internal/praefect/helper_test.go
index 16094ac6c00a63f91d736836a6830c71dd9a2ef6..2c30be1d648d118e829a51a5493068a73890b153 100644
--- a/internal/praefect/helper_test.go
+++ b/internal/praefect/helper_test.go
@@ -12,6 +12,7 @@ import (
 	"github.com/stretchr/testify/require"
 	"gitlab.com/gitlab-org/gitaly/client"
 	internalauth "gitlab.com/gitlab-org/gitaly/internal/config/auth"
+	repo "gitlab.com/gitlab-org/gitaly/internal/git/repository"
 	"gitlab.com/gitlab-org/gitaly/internal/log"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/config"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/datastore"
@@ -253,7 +254,7 @@ func runInternalGitalyServer(t *testing.T, token string) (*grpc.Server, string,
 	require.NoError(t, rubyServer.Start())
 
 	gitalypb.RegisterServerServiceServer(server, gitalyserver.NewServer())
-	gitalypb.RegisterRepositoryServiceServer(server, repository.NewServer(rubyServer))
+	gitalypb.RegisterRepositoryServiceServer(server, repository.NewServer(repo.NewTransactionManager(), rubyServer))
 	healthpb.RegisterHealthServer(server, health.NewServer())
 
 	errQ := make(chan error)
diff --git a/internal/praefect/replicator_test.go b/internal/praefect/replicator_test.go
index 24b10b051737eaf53c40cb691bd182b51d235dcb..9f3d77be0f3612f93313c22422dfcb27744012e2 100644
--- a/internal/praefect/replicator_test.go
+++ b/internal/praefect/replicator_test.go
@@ -13,6 +13,7 @@ import (
 	gitalyauth "gitlab.com/gitlab-org/gitaly/auth"
 	gitaly_config "gitlab.com/gitlab-org/gitaly/internal/config"
 	"gitlab.com/gitlab-org/gitaly/internal/git/objectpool"
+	repo "gitlab.com/gitlab-org/gitaly/internal/git/repository"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/config"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/datastore"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/models"
@@ -449,7 +450,7 @@ func newReplicationService(tb testing.TB) (*grpc.Server, string) {
 
 	svr := testhelper.NewTestGrpcServer(tb, nil, nil)
 
-	gitalypb.RegisterRepositoryServiceServer(svr, repository.NewServer(&rubyserver.Server{}))
+	gitalypb.RegisterRepositoryServiceServer(svr, repository.NewServer(repo.NewTransactionManager(), &rubyserver.Server{}))
 	gitalypb.RegisterObjectPoolServiceServer(svr, objectpoolservice.NewServer())
 	gitalypb.RegisterRemoteServiceServer(svr, remote.NewServer(&rubyserver.Server{}))
 	reflection.Register(svr)
diff --git a/internal/praefect/server.go b/internal/praefect/server.go
index 863c30a3b7f85077e5e541ce3c886a992c77cdd6..80c7337a7a0fd70ab74340789b8cdc4f72cdf678 100644
--- a/internal/praefect/server.go
+++ b/internal/praefect/server.go
@@ -106,6 +106,7 @@ func NewServer(c *Coordinator, repl ReplMgr, grpcOpts []grpc.ServerOption, l *lo
 	}
 
 	s.warnDupeAddrs(conf)
+	proxy.RegisterMutator(s.s, c.HandleWriteRef, "gitaly.RepositoryService", "WriteRef")
 
 	return s
 }
diff --git a/internal/server/server.go b/internal/server/server.go
index 250749248891d3e3084fdb919ca3f8036a6a8fd5..2e421d418decd5b00e606bd2bddc291c8a698dcf 100644
--- a/internal/server/server.go
+++ b/internal/server/server.go
@@ -12,6 +12,7 @@ import (
 	log "github.com/sirupsen/logrus"
 	diskcache "gitlab.com/gitlab-org/gitaly/internal/cache"
 	"gitlab.com/gitlab-org/gitaly/internal/config"
+	"gitlab.com/gitlab-org/gitaly/internal/git/repository"
 	"gitlab.com/gitlab-org/gitaly/internal/helper/fieldextractors"
 	gitalylog "gitlab.com/gitlab-org/gitaly/internal/log"
 	"gitlab.com/gitlab-org/gitaly/internal/logsanitizer"
@@ -20,7 +21,9 @@ import (
 	"gitlab.com/gitlab-org/gitaly/internal/middleware/limithandler"
 	"gitlab.com/gitlab-org/gitaly/internal/middleware/metadatahandler"
 	"gitlab.com/gitlab-org/gitaly/internal/middleware/panichandler"
+	"gitlab.com/gitlab-org/gitaly/internal/middleware/repositoryhandler"
 	"gitlab.com/gitlab-org/gitaly/internal/middleware/sentryhandler"
+	"gitlab.com/gitlab-org/gitaly/internal/praefect/grpc-proxy/proxy"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/protoregistry"
 	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
 	"gitlab.com/gitlab-org/gitaly/internal/server/auth"
@@ -76,7 +79,12 @@ func createNewServer(rubyServer *rubyserver.Server, secure bool) *grpc.Server {
 
 	lh := limithandler.New(concurrencyKeyFn)
 
+	transactionMgr := repository.NewTransactionManager()
+	registry := protoregistry.New()
+	registry.RegisterFiles(protoregistry.GitalyProtoFileDescriptors...)
+
 	opts := []grpc.ServerOption{
+		grpc.CustomCodec(proxy.Codec()),
 		grpc.StreamInterceptor(grpc_middleware.ChainStreamServer(
 			grpc_ctxtags.StreamServerInterceptor(ctxTagOpts...),
 			grpccorrelation.StreamServerCorrelationInterceptor(), // Must be above the metadata handler
@@ -92,6 +100,7 @@ func createNewServer(rubyServer *rubyserver.Server, secure bool) *grpc.Server {
 			// Panic handler should remain last so that application panics will be
 			// converted to errors and logged
 			panichandler.StreamPanicHandler,
+			repositoryhandler.RepositoryTransactionStreamInterceptor(transactionMgr, registry),
 		)),
 		grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(
 			grpc_ctxtags.UnaryServerInterceptor(ctxTagOpts...),
@@ -108,6 +117,7 @@ func createNewServer(rubyServer *rubyserver.Server, secure bool) *grpc.Server {
 			// Panic handler should remain last so that application panics will be
 			// converted to errors and logged
 			panichandler.UnaryPanicHandler,
+			repositoryhandler.RepositoryTransactionUnaryInterceptor(transactionMgr, registry),
 		)),
 	}
 
@@ -123,7 +133,7 @@ func createNewServer(rubyServer *rubyserver.Server, secure bool) *grpc.Server {
 
 	server := grpc.NewServer(opts...)
 
-	service.RegisterAll(server, rubyServer)
+	service.RegisterAll(server, rubyServer, transactionMgr)
 	reflection.Register(server)
 
 	grpc_prometheus.Register(server)
diff --git a/internal/service/register.go b/internal/service/register.go
index 119b01fa1a8aed953a1665326eef73b27fb6e4bb..597acf6109acb897775d75e4ef91ea81f87b4e68 100644
--- a/internal/service/register.go
+++ b/internal/service/register.go
@@ -1,6 +1,7 @@
 package service
 
 import (
+	repo "gitlab.com/gitlab-org/gitaly/internal/git/repository"
 	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
 	"gitlab.com/gitlab-org/gitaly/internal/service/blob"
 	"gitlab.com/gitlab-org/gitaly/internal/service/cleanup"
@@ -26,7 +27,7 @@ import (
 
 // RegisterAll will register all the known grpc services with
 // the specified grpc service instance
-func RegisterAll(grpcServer *grpc.Server, rubyServer *rubyserver.Server) {
+func RegisterAll(grpcServer *grpc.Server, rubyServer *rubyserver.Server, transactionMgr *repo.TransactionManager) {
 	gitalypb.RegisterBlobServiceServer(grpcServer, blob.NewServer(rubyServer))
 	gitalypb.RegisterCleanupServiceServer(grpcServer, cleanup.NewServer())
 	gitalypb.RegisterCommitServiceServer(grpcServer, commit.NewServer())
@@ -34,7 +35,7 @@ func RegisterAll(grpcServer *grpc.Server, rubyServer *rubyserver.Server) {
 	gitalypb.RegisterNamespaceServiceServer(grpcServer, namespace.NewServer())
 	gitalypb.RegisterOperationServiceServer(grpcServer, operations.NewServer(rubyServer))
 	gitalypb.RegisterRefServiceServer(grpcServer, ref.NewServer())
-	gitalypb.RegisterRepositoryServiceServer(grpcServer, repository.NewServer(rubyServer))
+	gitalypb.RegisterRepositoryServiceServer(grpcServer, repository.NewServer(transactionMgr, rubyServer))
 	gitalypb.RegisterSSHServiceServer(grpcServer, ssh.NewServer())
 	gitalypb.RegisterSmartHTTPServiceServer(grpcServer, smarthttp.NewServer())
 	gitalypb.RegisterWikiServiceServer(grpcServer, wiki.NewServer(rubyServer))
diff --git a/internal/service/repository/server.go b/internal/service/repository/server.go
index 2b4bb737ae3bcbb13cd9da613503cdd895c0a2e9..b833d59cfcf2a2ada05a914b7503e008ad9cdab7 100644
--- a/internal/service/repository/server.go
+++ b/internal/service/repository/server.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"sync"
 
+	"gitlab.com/gitlab-org/gitaly/internal/git/repository"
 	"gitlab.com/gitlab-org/gitaly/internal/helper"
 	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
@@ -15,11 +16,12 @@ type server struct {
 	gitalypb.UnimplementedRepositoryServiceServer
 	connsByAddress map[string]*grpc.ClientConn
 	connsMtx       sync.RWMutex
+	transactions   *repository.TransactionManager
 }
 
 // NewServer creates a new instance of a gRPC repo server
-func NewServer(rs *rubyserver.Server) gitalypb.RepositoryServiceServer {
-	return &server{ruby: rs, connsByAddress: make(map[string]*grpc.ClientConn)}
+func NewServer(transactions *repository.TransactionManager, rs *rubyserver.Server) gitalypb.RepositoryServiceServer {
+	return &server{ruby: rs, connsByAddress: make(map[string]*grpc.ClientConn), transactions: transactions}
 }
 
 func (*server) FetchHTTPRemote(context.Context, *gitalypb.FetchHTTPRemoteRequest) (*gitalypb.FetchHTTPRemoteResponse, error) {
diff --git a/internal/service/repository/testhelper_test.go b/internal/service/repository/testhelper_test.go
index 37c5e6d892e7e350c9f42499109815f41c318998..b2086aea431c1128e1a4aa49565bf58d8d1c26a9 100644
--- a/internal/service/repository/testhelper_test.go
+++ b/internal/service/repository/testhelper_test.go
@@ -14,6 +14,7 @@ import (
 	"gitlab.com/gitlab-org/gitaly/client"
 	dcache "gitlab.com/gitlab-org/gitaly/internal/cache"
 	"gitlab.com/gitlab-org/gitaly/internal/config"
+	repo "gitlab.com/gitlab-org/gitaly/internal/git/repository"
 	mcache "gitlab.com/gitlab-org/gitaly/internal/middleware/cache"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/protoregistry"
 	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
@@ -84,7 +85,7 @@ func runRepoServer(t *testing.T) (*grpc.Server, string) {
 		t.Fatal(err)
 	}
 
-	gitalypb.RegisterRepositoryServiceServer(server, NewServer(RubyServer))
+	gitalypb.RegisterRepositoryServiceServer(server, NewServer(repo.NewTransactionManager(), RubyServer))
 	reflection.Register(server)
 
 	go server.Serve(listener)
diff --git a/internal/service/repository/write_ref.go b/internal/service/repository/write_ref.go
index bbaf239cbabe24747382f4dfe83d987a6c9e31e0..9a94c1030edf43650dd3bae923cf0935dbf20a95 100644
--- a/internal/service/repository/write_ref.go
+++ b/internal/service/repository/write_ref.go
@@ -22,14 +22,14 @@ func (s *server) WriteRef(ctx context.Context, req *gitalypb.WriteRefRequest) (*
 	return &gitalypb.WriteRefResponse{}, nil
 }
 
-func writeRef(ctx context.Context, req *gitalypb.WriteRefRequest) error {
-	if string(req.Ref) == "HEAD" {
+func writeRef(ctx context.Context, req writeRefRequest) error {
+	if string(req.GetRef()) == "HEAD" {
 		return updateSymbolicRef(ctx, req)
 	}
 	return updateRef(ctx, req)
 }
 
-func updateSymbolicRef(ctx context.Context, req *gitalypb.WriteRefRequest) error {
+func updateSymbolicRef(ctx context.Context, req writeRefRequest) error {
 	cmd, err := git.SafeCmd(ctx, req.GetRepository(), nil, git.SubCmd{Name: "symbolic-ref", Args: []string{string(req.GetRef()), string(req.GetRevision())}})
 	if err != nil {
 		return fmt.Errorf("error when creating symbolic-ref command: %v", err)
@@ -40,7 +40,7 @@ func updateSymbolicRef(ctx context.Context, req *gitalypb.WriteRefRequest) error
 	return nil
 }
 
-func updateRef(ctx context.Context, req *gitalypb.WriteRefRequest) error {
+func updateRef(ctx context.Context, req writeRefRequest) error {
 	u, err := updateref.New(ctx, req.GetRepository())
 	if err != nil {
 		return fmt.Errorf("error when running creating new updater: %v", err)
@@ -54,20 +54,20 @@ func updateRef(ctx context.Context, req *gitalypb.WriteRefRequest) error {
 	return nil
 }
 
-func validateWriteRefRequest(req *gitalypb.WriteRefRequest) error {
-	if err := git.ValidateRevision(req.Ref); err != nil {
+func validateWriteRefRequest(req writeRefRequest) error {
+	if err := git.ValidateRevision(req.GetRef()); err != nil {
 		return fmt.Errorf("invalid ref: %v", err)
 	}
-	if err := git.ValidateRevision(req.Revision); err != nil {
+	if err := git.ValidateRevision(req.GetRevision()); err != nil {
 		return fmt.Errorf("invalid revision: %v", err)
 	}
-	if len(req.OldRevision) > 0 {
-		if err := git.ValidateRevision(req.OldRevision); err != nil {
+	if len(req.GetOldRevision()) > 0 {
+		if err := git.ValidateRevision(req.GetOldRevision()); err != nil {
 			return fmt.Errorf("invalid OldRevision: %v", err)
 		}
 	}
 
-	if !bytes.Equal(req.Ref, []byte("HEAD")) && !bytes.HasPrefix(req.Ref, []byte("refs/")) {
+	if !bytes.Equal(req.GetRef(), []byte("HEAD")) && !bytes.HasPrefix(req.GetRef(), []byte("refs/")) {
 		return fmt.Errorf("ref has to be a full reference")
 	}
 	return nil
diff --git a/internal/service/repository/write_ref_tx.go b/internal/service/repository/write_ref_tx.go
new file mode 100644
index 0000000000000000000000000000000000000000..f146e92aa56894686aa7a5ed4b56d1788150a87f
--- /dev/null
+++ b/internal/service/repository/write_ref_tx.go
@@ -0,0 +1,194 @@
+package repository
+
+import (
+	"context"
+	"errors"
+	"io/ioutil"
+	"os/exec"
+
+	"github.com/sirupsen/logrus"
+	"gitlab.com/gitlab-org/gitaly/internal/git"
+	"gitlab.com/gitlab-org/gitaly/internal/helper"
+	"gitlab.com/gitlab-org/gitaly/internal/helper/text"
+	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
+	"google.golang.org/grpc/metadata"
+)
+
+type writeRefRequest interface {
+	GetRef() []byte
+	GetRevision() []byte
+	GetOldRevision() []byte
+	GetRepository() *gitalypb.Repository
+}
+
+func (s *server) WriteRefTx(ctx context.Context, req *gitalypb.WriteRefTxRequest) (*gitalypb.WriteRefTxResponse, error) {
+	md, ok := metadata.FromIncomingContext(ctx)
+	if !ok {
+		return nil, helper.ErrInternal(errors.New("could not get metadata from context"))
+	}
+
+	transactionSteps := md.Get("transaction_step")
+
+	logrus.WithField("transaction_steps", transactionSteps).Info("got transaction steps")
+	if len(transactionSteps) == 0 {
+		return nil, nil
+	}
+
+	logrus.WithField("transaction_steps", transactionSteps).Info("got transaction steps")
+
+	transactionStep := transactionSteps[len(transactionSteps)-1]
+
+	if transactionStep == "precommit" {
+		logrus.WithField("relative_path", req.GetRepository().GetRelativePath()).WithField("ref", string(req.GetRef())).WithField("rev", string(req.GetRevision())).WithField("old_rev", string(req.GetOldRevision())).Info("WriteRefReqTx")
+		if err := validateWriteRefRequest(req); err != nil {
+			return nil, helper.ErrInvalidArgument(err)
+		}
+	}
+
+	return s.transactionalWriteRef(ctx, req, transactionStep)
+}
+
+func (s *server) transactionalWriteRef(ctx context.Context, req *gitalypb.WriteRefTxRequest, transactionStep string) (*gitalypb.WriteRefTxResponse, error) {
+	var resp gitalypb.WriteRefTxResponse
+
+	md, ok := metadata.FromIncomingContext(ctx)
+	if !ok {
+		return nil, helper.ErrInternal(errors.New("couldn't get metadata"))
+	}
+	if len(md.Get("transaction_id")) == 0 {
+		return nil, helper.ErrInternal(errors.New("expected request_id"))
+	}
+
+	transactionID := md.Get("transaction_id")[0]
+
+	switch transactionStep {
+	case "vote":
+		logrus.WithField("transaction_step", "vote").Info("transaction!")
+
+		s.transactions.Begin(transactionID)
+		err := vote(ctx, req)
+		if err != nil {
+			return nil, err
+		}
+	case "precommit":
+		logrus.WithField("transaction_step", "precommit").Info("transaction!")
+		rollback, err := rollbackRef(req)
+		if err != nil {
+			return nil, err
+		}
+		commit, err := preCommit(req)
+		if err != nil {
+			return nil, err
+		}
+
+		s.transactions.SetRollback(transactionID, rollback)
+		s.transactions.PreCommit(transactionID, commit)
+	case "commit":
+		logrus.WithField("transaction_step", "commit").Info("transaction!")
+		if err := s.transactions.Commit(transactionID); err != nil {
+			return nil, err
+		}
+	case "rollback":
+		logrus.WithField("transaction_step", "rollback").Info("transaction!")
+		if err := s.transactions.Rollback(transactionID); err != nil {
+			return nil, err
+		}
+	default:
+		return nil, errors.New("unknown transaction step")
+	}
+
+	return &resp, nil
+}
+
+func vote(ctx context.Context, req *gitalypb.WriteRefTxRequest) error {
+	if req.GetOldRevision() == nil {
+		return nil
+	}
+
+	cmd, err := git.SafeCmd(ctx, req.GetRepository(), nil, git.SubCmd{
+		Name: "rev-parse",
+		Args: []string{string(req.GetRef())},
+	})
+	if err != nil {
+		return err
+	}
+
+	if err := cmd.Wait(); err != nil {
+		return err
+	}
+
+	rev, err := ioutil.ReadAll(cmd)
+	if err != nil {
+		return err
+	}
+
+	if text.ChompBytes(rev) != string(req.GetOldRevision()) {
+		return errors.New("not ready")
+	}
+
+	return nil
+}
+
+func rollbackSymbolicRef(req *gitalypb.WriteRefTxRequest) (*exec.Cmd, error) {
+	repoPath, err := helper.GetRepoPath(req.GetRepository())
+	if err != nil {
+		return nil, err
+	}
+
+	return exec.Command("git", "-C", repoPath, "symoblic-ref", string(req.GetRef()), string(req.GetOldRevision())), nil
+}
+
+func rollbackRef(req *gitalypb.WriteRefTxRequest) (*exec.Cmd, error) {
+	if string(req.Ref) == "HEAD" {
+		return rollbackSymbolicRef(req)
+	}
+
+	repoPath, err := helper.GetRepoPath(req.GetRepository())
+	if err != nil {
+		return nil, err
+	}
+
+	args := []string{"-C", repoPath, "update-ref"}
+
+	if req.GetOldRevision() == nil {
+		args = append(args, "-d", string(req.GetRevision()))
+	} else {
+		args = append(args, string(req.GetOldRevision()), string(req.GetRevision()))
+	}
+
+	c := exec.Command("git", args...)
+
+	return c, nil
+}
+
+func preCommit(req *gitalypb.WriteRefTxRequest) (*exec.Cmd, error) {
+	if string(req.Ref) == "HEAD" {
+		return preCommitSymbolicRef(req)
+	}
+
+	repoPath, err := helper.GetRepoPath(req.GetRepository())
+	if err != nil {
+		return nil, err
+	}
+
+	args := []string{"-C", repoPath, "update-ref", string(req.GetRef()), string(req.GetRevision())}
+
+	if req.GetOldRevision() != nil {
+		args = append(args, string(req.GetOldRevision()))
+	}
+
+	c := exec.Command("git", args...)
+
+	logrus.WithField("DA COMMAND ARGS!!!", args).Info("1234567")
+
+	return c, nil
+}
+
+func preCommitSymbolicRef(req *gitalypb.WriteRefTxRequest) (*exec.Cmd, error) {
+	repoPath, err := helper.GetRepoPath(req.GetRepository())
+	if err != nil {
+		return nil, err
+	}
+
+	return exec.Command("git", "-C", repoPath, "symoblic-ref", string(req.GetRef()), string(req.GetRevision())), nil
+}
diff --git a/proto/go/gitalypb/repository-service.pb.go b/proto/go/gitalypb/repository-service.pb.go
index 645e56202d3689fd8215bc7e6d011418d7f2f3ac..2a2c6d6cb25d59f7cc63d8833ffa713878bf9edc 100644
--- a/proto/go/gitalypb/repository-service.pb.go
+++ b/proto/go/gitalypb/repository-service.pb.go
@@ -92,7 +92,7 @@ func (x GetRawChangesResponse_RawChange_Operation) String() string {
 }
 
 func (GetRawChangesResponse_RawChange_Operation) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{61, 0, 0}
+	return fileDescriptor_e9b1768cf174c79b, []int{63, 0, 0}
 }
 
 type RepositoryExistsRequest struct {
@@ -1300,6 +1300,108 @@ func (m *WriteRefResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_WriteRefResponse proto.InternalMessageInfo
 
+type WriteRefTxRequest struct {
+	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
+	Ref                  []byte      `protobuf:"bytes,2,opt,name=ref,proto3" json:"ref,omitempty"`
+	Revision             []byte      `protobuf:"bytes,3,opt,name=revision,proto3" json:"revision,omitempty"`
+	OldRevision          []byte      `protobuf:"bytes,4,opt,name=old_revision,json=oldRevision,proto3" json:"old_revision,omitempty"`
+	Force                bool        `protobuf:"varint,5,opt,name=force,proto3" json:"force,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *WriteRefTxRequest) Reset()         { *m = WriteRefTxRequest{} }
+func (m *WriteRefTxRequest) String() string { return proto.CompactTextString(m) }
+func (*WriteRefTxRequest) ProtoMessage()    {}
+func (*WriteRefTxRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e9b1768cf174c79b, []int{28}
+}
+
+func (m *WriteRefTxRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_WriteRefTxRequest.Unmarshal(m, b)
+}
+func (m *WriteRefTxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_WriteRefTxRequest.Marshal(b, m, deterministic)
+}
+func (m *WriteRefTxRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_WriteRefTxRequest.Merge(m, src)
+}
+func (m *WriteRefTxRequest) XXX_Size() int {
+	return xxx_messageInfo_WriteRefTxRequest.Size(m)
+}
+func (m *WriteRefTxRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_WriteRefTxRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_WriteRefTxRequest proto.InternalMessageInfo
+
+func (m *WriteRefTxRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *WriteRefTxRequest) GetRef() []byte {
+	if m != nil {
+		return m.Ref
+	}
+	return nil
+}
+
+func (m *WriteRefTxRequest) GetRevision() []byte {
+	if m != nil {
+		return m.Revision
+	}
+	return nil
+}
+
+func (m *WriteRefTxRequest) GetOldRevision() []byte {
+	if m != nil {
+		return m.OldRevision
+	}
+	return nil
+}
+
+func (m *WriteRefTxRequest) GetForce() bool {
+	if m != nil {
+		return m.Force
+	}
+	return false
+}
+
+type WriteRefTxResponse struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *WriteRefTxResponse) Reset()         { *m = WriteRefTxResponse{} }
+func (m *WriteRefTxResponse) String() string { return proto.CompactTextString(m) }
+func (*WriteRefTxResponse) ProtoMessage()    {}
+func (*WriteRefTxResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e9b1768cf174c79b, []int{29}
+}
+
+func (m *WriteRefTxResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_WriteRefTxResponse.Unmarshal(m, b)
+}
+func (m *WriteRefTxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_WriteRefTxResponse.Marshal(b, m, deterministic)
+}
+func (m *WriteRefTxResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_WriteRefTxResponse.Merge(m, src)
+}
+func (m *WriteRefTxResponse) XXX_Size() int {
+	return xxx_messageInfo_WriteRefTxResponse.Size(m)
+}
+func (m *WriteRefTxResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_WriteRefTxResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_WriteRefTxResponse proto.InternalMessageInfo
+
 type FindMergeBaseRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
 	// We use a repeated field because rugged supports finding a base
@@ -1315,7 +1417,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_e9b1768cf174c79b, []int{28}
+	return fileDescriptor_e9b1768cf174c79b, []int{30}
 }
 
 func (m *FindMergeBaseRequest) XXX_Unmarshal(b []byte) error {
@@ -1361,7 +1463,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_e9b1768cf174c79b, []int{29}
+	return fileDescriptor_e9b1768cf174c79b, []int{31}
 }
 
 func (m *FindMergeBaseResponse) XXX_Unmarshal(b []byte) error {
@@ -1401,7 +1503,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_e9b1768cf174c79b, []int{30}
+	return fileDescriptor_e9b1768cf174c79b, []int{32}
 }
 
 func (m *CreateForkRequest) XXX_Unmarshal(b []byte) error {
@@ -1446,7 +1548,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_e9b1768cf174c79b, []int{31}
+	return fileDescriptor_e9b1768cf174c79b, []int{33}
 }
 
 func (m *CreateForkResponse) XXX_Unmarshal(b []byte) error {
@@ -1479,7 +1581,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_e9b1768cf174c79b, []int{32}
+	return fileDescriptor_e9b1768cf174c79b, []int{34}
 }
 
 func (m *IsRebaseInProgressRequest) XXX_Unmarshal(b []byte) error {
@@ -1525,7 +1627,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_e9b1768cf174c79b, []int{33}
+	return fileDescriptor_e9b1768cf174c79b, []int{35}
 }
 
 func (m *IsRebaseInProgressResponse) XXX_Unmarshal(b []byte) error {
@@ -1565,7 +1667,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_e9b1768cf174c79b, []int{34}
+	return fileDescriptor_e9b1768cf174c79b, []int{36}
 }
 
 func (m *IsSquashInProgressRequest) XXX_Unmarshal(b []byte) error {
@@ -1611,7 +1713,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_e9b1768cf174c79b, []int{35}
+	return fileDescriptor_e9b1768cf174c79b, []int{37}
 }
 
 func (m *IsSquashInProgressResponse) XXX_Unmarshal(b []byte) error {
@@ -1651,7 +1753,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_e9b1768cf174c79b, []int{36}
+	return fileDescriptor_e9b1768cf174c79b, []int{38}
 }
 
 func (m *CreateRepositoryFromURLRequest) XXX_Unmarshal(b []byte) error {
@@ -1696,7 +1798,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_e9b1768cf174c79b, []int{37}
+	return fileDescriptor_e9b1768cf174c79b, []int{39}
 }
 
 func (m *CreateRepositoryFromURLResponse) XXX_Unmarshal(b []byte) error {
@@ -1728,7 +1830,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_e9b1768cf174c79b, []int{38}
+	return fileDescriptor_e9b1768cf174c79b, []int{40}
 }
 
 func (m *CreateBundleRequest) XXX_Unmarshal(b []byte) error {
@@ -1767,7 +1869,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_e9b1768cf174c79b, []int{39}
+	return fileDescriptor_e9b1768cf174c79b, []int{41}
 }
 
 func (m *CreateBundleResponse) XXX_Unmarshal(b []byte) error {
@@ -1807,7 +1909,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_e9b1768cf174c79b, []int{40}
+	return fileDescriptor_e9b1768cf174c79b, []int{42}
 }
 
 func (m *SetConfigRequest) XXX_Unmarshal(b []byte) error {
@@ -1858,7 +1960,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_e9b1768cf174c79b, []int{40, 0}
+	return fileDescriptor_e9b1768cf174c79b, []int{42, 0}
 }
 
 func (m *SetConfigRequest_Entry) XXX_Unmarshal(b []byte) error {
@@ -1955,7 +2057,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_e9b1768cf174c79b, []int{41}
+	return fileDescriptor_e9b1768cf174c79b, []int{43}
 }
 
 func (m *SetConfigResponse) XXX_Unmarshal(b []byte) error {
@@ -1988,7 +2090,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_e9b1768cf174c79b, []int{42}
+	return fileDescriptor_e9b1768cf174c79b, []int{44}
 }
 
 func (m *DeleteConfigRequest) XXX_Unmarshal(b []byte) error {
@@ -2033,7 +2135,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_e9b1768cf174c79b, []int{43}
+	return fileDescriptor_e9b1768cf174c79b, []int{45}
 }
 
 func (m *DeleteConfigResponse) XXX_Unmarshal(b []byte) error {
@@ -2066,7 +2168,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_e9b1768cf174c79b, []int{44}
+	return fileDescriptor_e9b1768cf174c79b, []int{46}
 }
 
 func (m *RestoreCustomHooksRequest) XXX_Unmarshal(b []byte) error {
@@ -2111,7 +2213,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_e9b1768cf174c79b, []int{45}
+	return fileDescriptor_e9b1768cf174c79b, []int{47}
 }
 
 func (m *RestoreCustomHooksResponse) XXX_Unmarshal(b []byte) error {
@@ -2143,7 +2245,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_e9b1768cf174c79b, []int{46}
+	return fileDescriptor_e9b1768cf174c79b, []int{48}
 }
 
 func (m *BackupCustomHooksRequest) XXX_Unmarshal(b []byte) error {
@@ -2182,7 +2284,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_e9b1768cf174c79b, []int{47}
+	return fileDescriptor_e9b1768cf174c79b, []int{49}
 }
 
 func (m *BackupCustomHooksResponse) XXX_Unmarshal(b []byte) error {
@@ -2223,7 +2325,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_e9b1768cf174c79b, []int{48}
+	return fileDescriptor_e9b1768cf174c79b, []int{50}
 }
 
 func (m *CreateRepositoryFromBundleRequest) XXX_Unmarshal(b []byte) error {
@@ -2268,7 +2370,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_e9b1768cf174c79b, []int{49}
+	return fileDescriptor_e9b1768cf174c79b, []int{51}
 }
 
 func (m *CreateRepositoryFromBundleResponse) XXX_Unmarshal(b []byte) error {
@@ -2300,7 +2402,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_e9b1768cf174c79b, []int{50}
+	return fileDescriptor_e9b1768cf174c79b, []int{52}
 }
 
 func (m *FindLicenseRequest) XXX_Unmarshal(b []byte) error {
@@ -2339,7 +2441,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_e9b1768cf174c79b, []int{51}
+	return fileDescriptor_e9b1768cf174c79b, []int{53}
 }
 
 func (m *FindLicenseResponse) XXX_Unmarshal(b []byte) error {
@@ -2378,7 +2480,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_e9b1768cf174c79b, []int{52}
+	return fileDescriptor_e9b1768cf174c79b, []int{54}
 }
 
 func (m *GetInfoAttributesRequest) XXX_Unmarshal(b []byte) error {
@@ -2417,7 +2519,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_e9b1768cf174c79b, []int{53}
+	return fileDescriptor_e9b1768cf174c79b, []int{55}
 }
 
 func (m *GetInfoAttributesResponse) XXX_Unmarshal(b []byte) error {
@@ -2456,7 +2558,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_e9b1768cf174c79b, []int{54}
+	return fileDescriptor_e9b1768cf174c79b, []int{56}
 }
 
 func (m *CalculateChecksumRequest) XXX_Unmarshal(b []byte) error {
@@ -2495,7 +2597,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_e9b1768cf174c79b, []int{55}
+	return fileDescriptor_e9b1768cf174c79b, []int{57}
 }
 
 func (m *CalculateChecksumResponse) XXX_Unmarshal(b []byte) error {
@@ -2534,7 +2636,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_e9b1768cf174c79b, []int{56}
+	return fileDescriptor_e9b1768cf174c79b, []int{58}
 }
 
 func (m *GetSnapshotRequest) XXX_Unmarshal(b []byte) error {
@@ -2573,7 +2675,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_e9b1768cf174c79b, []int{57}
+	return fileDescriptor_e9b1768cf174c79b, []int{59}
 }
 
 func (m *GetSnapshotResponse) XXX_Unmarshal(b []byte) error {
@@ -2614,7 +2716,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_e9b1768cf174c79b, []int{58}
+	return fileDescriptor_e9b1768cf174c79b, []int{60}
 }
 
 func (m *CreateRepositoryFromSnapshotRequest) XXX_Unmarshal(b []byte) error {
@@ -2666,7 +2768,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_e9b1768cf174c79b, []int{59}
+	return fileDescriptor_e9b1768cf174c79b, []int{61}
 }
 
 func (m *CreateRepositoryFromSnapshotResponse) XXX_Unmarshal(b []byte) error {
@@ -2700,7 +2802,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_e9b1768cf174c79b, []int{60}
+	return fileDescriptor_e9b1768cf174c79b, []int{62}
 }
 
 func (m *GetRawChangesRequest) XXX_Unmarshal(b []byte) error {
@@ -2753,7 +2855,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_e9b1768cf174c79b, []int{61}
+	return fileDescriptor_e9b1768cf174c79b, []int{63}
 }
 
 func (m *GetRawChangesResponse) XXX_Unmarshal(b []byte) error {
@@ -2803,7 +2905,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_e9b1768cf174c79b, []int{61, 0}
+	return fileDescriptor_e9b1768cf174c79b, []int{63, 0}
 }
 
 func (m *GetRawChangesResponse_RawChange) XXX_Unmarshal(b []byte) error {
@@ -2909,7 +3011,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_e9b1768cf174c79b, []int{62}
+	return fileDescriptor_e9b1768cf174c79b, []int{64}
 }
 
 func (m *SearchFilesByNameRequest) XXX_Unmarshal(b []byte) error {
@@ -2962,7 +3064,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_e9b1768cf174c79b, []int{63}
+	return fileDescriptor_e9b1768cf174c79b, []int{65}
 }
 
 func (m *SearchFilesByNameResponse) XXX_Unmarshal(b []byte) error {
@@ -3004,7 +3106,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_e9b1768cf174c79b, []int{64}
+	return fileDescriptor_e9b1768cf174c79b, []int{66}
 }
 
 func (m *SearchFilesByContentRequest) XXX_Unmarshal(b []byte) error {
@@ -3066,7 +3168,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_e9b1768cf174c79b, []int{65}
+	return fileDescriptor_e9b1768cf174c79b, []int{67}
 }
 
 func (m *SearchFilesByContentResponse) XXX_Unmarshal(b []byte) error {
@@ -3122,7 +3224,7 @@ 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_e9b1768cf174c79b, []int{66}
+	return fileDescriptor_e9b1768cf174c79b, []int{68}
 }
 
 func (m *Remote) XXX_Unmarshal(b []byte) error {
@@ -3184,7 +3286,7 @@ 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_e9b1768cf174c79b, []int{67}
+	return fileDescriptor_e9b1768cf174c79b, []int{69}
 }
 
 func (m *FetchHTTPRemoteRequest) XXX_Unmarshal(b []byte) error {
@@ -3236,7 +3338,7 @@ 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_e9b1768cf174c79b, []int{68}
+	return fileDescriptor_e9b1768cf174c79b, []int{70}
 }
 
 func (m *FetchHTTPRemoteResponse) XXX_Unmarshal(b []byte) error {
@@ -3268,7 +3370,7 @@ func (m *GetObjectDirectorySizeRequest) Reset()         { *m = GetObjectDirector
 func (m *GetObjectDirectorySizeRequest) String() string { return proto.CompactTextString(m) }
 func (*GetObjectDirectorySizeRequest) ProtoMessage()    {}
 func (*GetObjectDirectorySizeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{69}
+	return fileDescriptor_e9b1768cf174c79b, []int{71}
 }
 
 func (m *GetObjectDirectorySizeRequest) XXX_Unmarshal(b []byte) error {
@@ -3308,7 +3410,7 @@ func (m *GetObjectDirectorySizeResponse) Reset()         { *m = GetObjectDirecto
 func (m *GetObjectDirectorySizeResponse) String() string { return proto.CompactTextString(m) }
 func (*GetObjectDirectorySizeResponse) ProtoMessage()    {}
 func (*GetObjectDirectorySizeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{70}
+	return fileDescriptor_e9b1768cf174c79b, []int{72}
 }
 
 func (m *GetObjectDirectorySizeResponse) XXX_Unmarshal(b []byte) error {
@@ -3349,7 +3451,7 @@ func (m *CloneFromPoolRequest) Reset()         { *m = CloneFromPoolRequest{} }
 func (m *CloneFromPoolRequest) String() string { return proto.CompactTextString(m) }
 func (*CloneFromPoolRequest) ProtoMessage()    {}
 func (*CloneFromPoolRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{71}
+	return fileDescriptor_e9b1768cf174c79b, []int{73}
 }
 
 func (m *CloneFromPoolRequest) XXX_Unmarshal(b []byte) error {
@@ -3401,7 +3503,7 @@ func (m *CloneFromPoolResponse) Reset()         { *m = CloneFromPoolResponse{} }
 func (m *CloneFromPoolResponse) String() string { return proto.CompactTextString(m) }
 func (*CloneFromPoolResponse) ProtoMessage()    {}
 func (*CloneFromPoolResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{72}
+	return fileDescriptor_e9b1768cf174c79b, []int{74}
 }
 
 func (m *CloneFromPoolResponse) XXX_Unmarshal(b []byte) error {
@@ -3435,7 +3537,7 @@ func (m *CloneFromPoolInternalRequest) Reset()         { *m = CloneFromPoolInter
 func (m *CloneFromPoolInternalRequest) String() string { return proto.CompactTextString(m) }
 func (*CloneFromPoolInternalRequest) ProtoMessage()    {}
 func (*CloneFromPoolInternalRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{73}
+	return fileDescriptor_e9b1768cf174c79b, []int{75}
 }
 
 func (m *CloneFromPoolInternalRequest) XXX_Unmarshal(b []byte) error {
@@ -3487,7 +3589,7 @@ func (m *CloneFromPoolInternalResponse) Reset()         { *m = CloneFromPoolInte
 func (m *CloneFromPoolInternalResponse) String() string { return proto.CompactTextString(m) }
 func (*CloneFromPoolInternalResponse) ProtoMessage()    {}
 func (*CloneFromPoolInternalResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{74}
+	return fileDescriptor_e9b1768cf174c79b, []int{76}
 }
 
 func (m *CloneFromPoolInternalResponse) XXX_Unmarshal(b []byte) error {
@@ -3519,7 +3621,7 @@ func (m *RemoveRepositoryRequest) Reset()         { *m = RemoveRepositoryRequest
 func (m *RemoveRepositoryRequest) String() string { return proto.CompactTextString(m) }
 func (*RemoveRepositoryRequest) ProtoMessage()    {}
 func (*RemoveRepositoryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{75}
+	return fileDescriptor_e9b1768cf174c79b, []int{77}
 }
 
 func (m *RemoveRepositoryRequest) XXX_Unmarshal(b []byte) error {
@@ -3557,7 +3659,7 @@ func (m *RemoveRepositoryResponse) Reset()         { *m = RemoveRepositoryRespon
 func (m *RemoveRepositoryResponse) String() string { return proto.CompactTextString(m) }
 func (*RemoveRepositoryResponse) ProtoMessage()    {}
 func (*RemoveRepositoryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{76}
+	return fileDescriptor_e9b1768cf174c79b, []int{78}
 }
 
 func (m *RemoveRepositoryResponse) XXX_Unmarshal(b []byte) error {
@@ -3590,7 +3692,7 @@ func (m *RenameRepositoryRequest) Reset()         { *m = RenameRepositoryRequest
 func (m *RenameRepositoryRequest) String() string { return proto.CompactTextString(m) }
 func (*RenameRepositoryRequest) ProtoMessage()    {}
 func (*RenameRepositoryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{77}
+	return fileDescriptor_e9b1768cf174c79b, []int{79}
 }
 
 func (m *RenameRepositoryRequest) XXX_Unmarshal(b []byte) error {
@@ -3635,7 +3737,7 @@ func (m *RenameRepositoryResponse) Reset()         { *m = RenameRepositoryRespon
 func (m *RenameRepositoryResponse) String() string { return proto.CompactTextString(m) }
 func (*RenameRepositoryResponse) ProtoMessage()    {}
 func (*RenameRepositoryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{78}
+	return fileDescriptor_e9b1768cf174c79b, []int{80}
 }
 
 func (m *RenameRepositoryResponse) XXX_Unmarshal(b []byte) error {
@@ -3668,7 +3770,7 @@ func (m *ReplicateRepositoryRequest) Reset()         { *m = ReplicateRepositoryR
 func (m *ReplicateRepositoryRequest) String() string { return proto.CompactTextString(m) }
 func (*ReplicateRepositoryRequest) ProtoMessage()    {}
 func (*ReplicateRepositoryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{79}
+	return fileDescriptor_e9b1768cf174c79b, []int{81}
 }
 
 func (m *ReplicateRepositoryRequest) XXX_Unmarshal(b []byte) error {
@@ -3713,7 +3815,7 @@ func (m *ReplicateRepositoryResponse) Reset()         { *m = ReplicateRepository
 func (m *ReplicateRepositoryResponse) String() string { return proto.CompactTextString(m) }
 func (*ReplicateRepositoryResponse) ProtoMessage()    {}
 func (*ReplicateRepositoryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e9b1768cf174c79b, []int{80}
+	return fileDescriptor_e9b1768cf174c79b, []int{82}
 }
 
 func (m *ReplicateRepositoryResponse) XXX_Unmarshal(b []byte) error {
@@ -3765,6 +3867,8 @@ func init() {
 	proto.RegisterType((*FsckResponse)(nil), "gitaly.FsckResponse")
 	proto.RegisterType((*WriteRefRequest)(nil), "gitaly.WriteRefRequest")
 	proto.RegisterType((*WriteRefResponse)(nil), "gitaly.WriteRefResponse")
+	proto.RegisterType((*WriteRefTxRequest)(nil), "gitaly.WriteRefTxRequest")
+	proto.RegisterType((*WriteRefTxResponse)(nil), "gitaly.WriteRefTxResponse")
 	proto.RegisterType((*FindMergeBaseRequest)(nil), "gitaly.FindMergeBaseRequest")
 	proto.RegisterType((*FindMergeBaseResponse)(nil), "gitaly.FindMergeBaseResponse")
 	proto.RegisterType((*CreateForkRequest)(nil), "gitaly.CreateForkRequest")
@@ -3825,190 +3929,193 @@ func init() {
 func init() { proto.RegisterFile("repository-service.proto", fileDescriptor_e9b1768cf174c79b) }
 
 var fileDescriptor_e9b1768cf174c79b = []byte{
-	// 2925 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x4b, 0x6f, 0x1c, 0xc7,
-	0xf1, 0xd7, 0xf2, 0xb5, 0xbb, 0xc5, 0x95, 0xb4, 0x6c, 0x52, 0xe4, 0x72, 0x44, 0x8a, 0xd2, 0x48,
-	0x96, 0x65, 0x5b, 0xa6, 0x64, 0xea, 0x0f, 0xfc, 0x9d, 0x04, 0x41, 0xc0, 0xe5, 0x5b, 0x0f, 0x92,
-	0x1e, 0xd2, 0x31, 0x2c, 0xc0, 0x18, 0xcf, 0xce, 0xf6, 0x72, 0x27, 0x9c, 0x9d, 0x5e, 0xcd, 0xf4,
-	0x92, 0xa6, 0x91, 0x1c, 0x12, 0xc0, 0x57, 0x03, 0x01, 0x82, 0x38, 0xc7, 0x9c, 0x72, 0xc8, 0x27,
-	0xc8, 0x25, 0x08, 0x72, 0xc9, 0x77, 0xf0, 0x57, 0xc9, 0x29, 0xe8, 0xc7, 0x4c, 0xcf, 0x73, 0xad,
-	0x60, 0x17, 0xce, 0x6d, 0xba, 0xba, 0xba, 0xaa, 0xba, 0xba, 0xfa, 0x51, 0xbf, 0x1a, 0x68, 0xf8,
-	0xb8, 0x4f, 0x02, 0x87, 0x12, 0xff, 0xea, 0xc3, 0x00, 0xfb, 0x17, 0x8e, 0x8d, 0xd7, 0xfb, 0x3e,
-	0xa1, 0x04, 0xcd, 0x9c, 0x39, 0xd4, 0x72, 0xaf, 0xb4, 0x5a, 0xd0, 0xb5, 0x7c, 0xdc, 0x16, 0x54,
-	0xfd, 0x04, 0x96, 0x8c, 0x68, 0xc4, 0xce, 0x57, 0x4e, 0x40, 0x03, 0x03, 0xbf, 0x19, 0xe0, 0x80,
-	0xa2, 0x8f, 0x01, 0x94, 0xb0, 0x46, 0xe9, 0x6e, 0xe9, 0xd1, 0xec, 0x06, 0x5a, 0x17, 0x52, 0xd6,
-	0xd5, 0xa0, 0xe6, 0xd4, 0x9f, 0xfe, 0xf5, 0xb8, 0x64, 0xc4, 0x78, 0xf5, 0x0d, 0x68, 0x64, 0x85,
-	0x06, 0x7d, 0xe2, 0x05, 0x18, 0x2d, 0xc2, 0x0c, 0xe6, 0x14, 0x2e, 0xb1, 0x62, 0xc8, 0x96, 0x7e,
-	0xca, 0xc7, 0x58, 0xf6, 0xf9, 0x81, 0x67, 0xfb, 0xb8, 0x87, 0x3d, 0x6a, 0xb9, 0xa3, 0x5b, 0x72,
-	0x1b, 0x96, 0x73, 0xa4, 0x0a, 0x53, 0x74, 0x1f, 0xe6, 0x44, 0xe7, 0xee, 0xc0, 0x1d, 0x5d, 0x17,
-	0xba, 0x0f, 0xd7, 0x6d, 0x1f, 0x5b, 0x14, 0x9b, 0x2d, 0x87, 0xf6, 0xac, 0x7e, 0x63, 0x82, 0x4f,
-	0xb0, 0x26, 0x88, 0x4d, 0x4e, 0xd3, 0x17, 0x00, 0xc5, 0x75, 0x4a, 0x4b, 0x2e, 0xe0, 0xd6, 0x9e,
-	0xe5, 0xb7, 0xac, 0x33, 0xbc, 0x45, 0x5c, 0x17, 0xdb, 0xf4, 0x47, 0xb2, 0xa6, 0x01, 0x8b, 0x69,
-	0xbd, 0xd2, 0xa2, 0xe7, 0x70, 0x63, 0xcb, 0xc5, 0x96, 0x37, 0xe8, 0x8f, 0xbe, 0x08, 0x73, 0x70,
-	0x33, 0x92, 0x25, 0xc5, 0x7f, 0x02, 0xb7, 0xd4, 0x90, 0x13, 0xe7, 0x6b, 0x3c, 0xba, 0x96, 0xc7,
-	0xb0, 0x98, 0x16, 0x29, 0x43, 0x0e, 0xc1, 0x54, 0xe0, 0x7c, 0x8d, 0xb9, 0xb4, 0x49, 0x83, 0x7f,
-	0xeb, 0x6f, 0x60, 0x79, 0xb3, 0xdf, 0x77, 0xaf, 0xf6, 0x1c, 0x6a, 0x51, 0xea, 0x3b, 0xad, 0x01,
-	0xc5, 0xa3, 0x47, 0x3e, 0xd2, 0xa0, 0xe2, 0xe3, 0x0b, 0x27, 0x70, 0x88, 0xc7, 0x1d, 0x5e, 0x33,
-	0xa2, 0xb6, 0xbe, 0x02, 0x5a, 0x9e, 0x4a, 0xe9, 0x91, 0x7f, 0x4c, 0x00, 0xda, 0xc5, 0xd4, 0xee,
-	0x1a, 0xb8, 0x47, 0xe8, 0xe8, 0xfe, 0x60, 0x1b, 0xcd, 0xe7, 0xa2, 0xb8, 0x21, 0x55, 0x43, 0xb6,
-	0xd0, 0x02, 0x4c, 0x77, 0x88, 0x6f, 0xe3, 0xc6, 0x24, 0x0f, 0x08, 0xd1, 0x40, 0x4b, 0x50, 0xf6,
-	0x88, 0x49, 0xad, 0xb3, 0xa0, 0x31, 0x25, 0xf6, 0xa5, 0x47, 0x4e, 0xad, 0xb3, 0x00, 0x35, 0xa0,
-	0x4c, 0x9d, 0x1e, 0x26, 0x03, 0xda, 0x98, 0xbe, 0x5b, 0x7a, 0x34, 0x6d, 0x84, 0x4d, 0x36, 0x24,
-	0x08, 0xba, 0xe6, 0x39, 0xbe, 0x6a, 0xcc, 0x08, 0x0d, 0x41, 0xd0, 0x7d, 0x81, 0xaf, 0xd0, 0x1a,
-	0xcc, 0x9e, 0x7b, 0xe4, 0xd2, 0x33, 0xbb, 0x84, 0xed, 0xf3, 0x32, 0xef, 0x04, 0x4e, 0xda, 0x67,
-	0x14, 0xb4, 0x0c, 0x15, 0x8f, 0x98, 0x7d, 0x7f, 0xe0, 0xe1, 0x46, 0x95, 0x6b, 0x2b, 0x7b, 0xe4,
-	0x98, 0x35, 0xd1, 0x33, 0xb8, 0x2e, 0xec, 0x34, 0xfb, 0x96, 0x6f, 0xf5, 0x82, 0x06, 0xf0, 0x29,
-	0xdf, 0x50, 0x53, 0xe6, 0xde, 0xa9, 0x09, 0xa6, 0x63, 0xce, 0xf3, 0x7c, 0xaa, 0x52, 0xa9, 0x57,
-	0xf5, 0x5b, 0x30, 0x9f, 0x70, 0xa0, 0x74, 0xec, 0x09, 0x2c, 0x6d, 0xf1, 0x98, 0x57, 0xde, 0x1a,
-	0x3d, 0xd8, 0x34, 0x68, 0x64, 0x85, 0x4a, 0x85, 0xdf, 0x4c, 0xc0, 0xdc, 0x1e, 0xa6, 0x9b, 0xbe,
-	0xdd, 0x75, 0x2e, 0xc6, 0xb0, 0x90, 0xb7, 0xa1, 0x6a, 0x93, 0x5e, 0xcf, 0xa1, 0xa6, 0xd3, 0x96,
-	0x6b, 0x59, 0x11, 0x84, 0x83, 0x36, 0x5b, 0xe5, 0xbe, 0x8f, 0x3b, 0xce, 0x57, 0x7c, 0x39, 0xab,
-	0x86, 0x6c, 0xa1, 0x8f, 0x61, 0xa6, 0x43, 0xfc, 0x9e, 0x45, 0xf9, 0x72, 0xde, 0xd8, 0xb8, 0x1b,
-	0xaa, 0xca, 0x58, 0xb6, 0xbe, 0xcb, 0xf9, 0x0c, 0xc9, 0xcf, 0x76, 0x4b, 0xdf, 0xa2, 0x5d, 0xbe,
-	0xda, 0x35, 0x83, 0x7f, 0xeb, 0xcf, 0x60, 0x46, 0x70, 0xa1, 0x32, 0x4c, 0xbe, 0x3e, 0x38, 0xae,
-	0x5f, 0x63, 0x1f, 0xa7, 0x9b, 0x46, 0xbd, 0x84, 0x00, 0x66, 0x4e, 0x37, 0x0d, 0x73, 0xef, 0x75,
-	0x7d, 0x02, 0xcd, 0x42, 0x99, 0x7d, 0x37, 0x5f, 0x6f, 0xd4, 0x27, 0xf5, 0x47, 0x80, 0xe2, 0xca,
-	0xd4, 0x66, 0x6c, 0x5b, 0xd4, 0xe2, 0x1e, 0xa8, 0x19, 0xfc, 0x9b, 0x2d, 0xd1, 0xbe, 0x15, 0xbc,
-	0x24, 0xb6, 0xe5, 0x36, 0x7d, 0xcb, 0xb3, 0xbb, 0x63, 0xd8, 0x8a, 0xfa, 0x53, 0x68, 0x64, 0x85,
-	0x4a, 0x23, 0x16, 0x60, 0xfa, 0xc2, 0x72, 0x07, 0x58, 0xde, 0x41, 0xa2, 0xa1, 0x7f, 0x5f, 0x82,
-	0x06, 0x8f, 0xa0, 0x13, 0x32, 0xf0, 0x6d, 0x2c, 0x46, 0x8d, 0xbe, 0x7e, 0xbf, 0x80, 0xb9, 0x80,
-	0x0b, 0x34, 0x63, 0x02, 0x26, 0x8a, 0x04, 0x18, 0x75, 0xc1, 0x6c, 0x24, 0x8e, 0x72, 0x29, 0xa0,
-	0xc5, 0x4d, 0xe2, 0x4b, 0x5d, 0x33, 0x6a, 0x41, 0xcc, 0x4c, 0xb4, 0x0a, 0x40, 0x2d, 0xff, 0x0c,
-	0x53, 0xd3, 0xc7, 0x1d, 0xbe, 0xe8, 0x35, 0xa3, 0x2a, 0x28, 0x06, 0xee, 0xe8, 0xcf, 0x60, 0x39,
-	0x67, 0x6a, 0xea, 0x4e, 0xf6, 0x71, 0x30, 0x70, 0x69, 0x78, 0x27, 0x8b, 0x96, 0xbe, 0x07, 0xb3,
-	0xbb, 0x81, 0x7d, 0x3e, 0xfa, 0x5a, 0x3c, 0x80, 0x9a, 0x10, 0xa4, 0xfc, 0x8f, 0x7d, 0x9f, 0xf8,
-	0x32, 0x0a, 0x44, 0x43, 0xff, 0x5b, 0x09, 0x6e, 0x7e, 0xe6, 0x3b, 0x6c, 0x53, 0x75, 0x46, 0x77,
-	0x7b, 0x1d, 0x26, 0x99, 0x27, 0xc4, 0x29, 0xcc, 0x3e, 0x13, 0x87, 0xf3, 0x64, 0xf2, 0x70, 0x46,
-	0xf7, 0xa0, 0x46, 0xdc, 0xb6, 0x19, 0xf5, 0x0b, 0x07, 0xce, 0x12, 0xb7, 0x6d, 0x84, 0x2c, 0xd1,
-	0xc1, 0x39, 0x1d, 0x3b, 0x38, 0x9f, 0x4f, 0x55, 0x66, 0xea, 0x65, 0xbd, 0x01, 0x75, 0x65, 0xb9,
-	0x98, 0xe4, 0xf3, 0xa9, 0x4a, 0xa9, 0x3e, 0xa1, 0x7b, 0xb0, 0xb0, 0xeb, 0x78, 0xed, 0x57, 0xd8,
-	0x3f, 0xc3, 0x4d, 0x2b, 0x18, 0xc3, 0x79, 0xb0, 0x02, 0xd5, 0xd0, 0xcc, 0xa0, 0x31, 0x71, 0x77,
-	0x92, 0x2d, 0x74, 0x44, 0xd0, 0x3f, 0x80, 0x5b, 0x29, 0x7d, 0x6a, 0xe3, 0xb5, 0xac, 0x40, 0x84,
-	0x7c, 0xd5, 0xe0, 0xdf, 0xfa, 0xb7, 0x25, 0x98, 0x13, 0xe7, 0xd8, 0x2e, 0xf1, 0xcf, 0xff, 0xf7,
-	0xa1, 0xce, 0x9e, 0x47, 0x71, 0x7b, 0xa2, 0x87, 0xda, 0xf2, 0x41, 0x60, 0x60, 0x66, 0xf2, 0x81,
-	0x77, 0xec, 0x93, 0x33, 0x1f, 0x07, 0xc1, 0x58, 0x0e, 0x56, 0x9f, 0x0b, 0x8d, 0x1d, 0xac, 0x82,
-	0x70, 0xd0, 0xd6, 0x7f, 0x0e, 0x5a, 0x9e, 0x4e, 0xe9, 0xcc, 0x35, 0x98, 0x75, 0x3c, 0xb3, 0x2f,
-	0xc9, 0x72, 0xdb, 0x80, 0x13, 0x31, 0x0a, 0x93, 0x4f, 0xde, 0x0c, 0xac, 0xa0, 0x3b, 0x66, 0x93,
-	0x03, 0x2e, 0x34, 0x66, 0xb2, 0x20, 0x84, 0x26, 0x67, 0x75, 0xbe, 0xad, 0xc9, 0x2e, 0xdc, 0x49,
-	0xdf, 0x69, 0xbb, 0x3e, 0xe9, 0x7d, 0x6a, 0xbc, 0x1c, 0xcb, 0x66, 0x1c, 0xf8, 0xae, 0xb4, 0x98,
-	0x7d, 0xea, 0xf7, 0x60, 0xad, 0x50, 0x9b, 0x5c, 0xf6, 0x23, 0x98, 0x17, 0x2c, 0xcd, 0x81, 0xd7,
-	0x76, 0xc7, 0xf0, 0x44, 0x7c, 0x1f, 0x16, 0x92, 0x02, 0x87, 0xdc, 0x49, 0xdf, 0x4e, 0x40, 0xfd,
-	0x04, 0xd3, 0x2d, 0xe2, 0x75, 0x9c, 0xb3, 0xd1, 0x1d, 0xf0, 0x31, 0x94, 0xb1, 0x47, 0x7d, 0x07,
-	0x8b, 0x2d, 0x3b, 0xbb, 0x71, 0x27, 0x1c, 0x96, 0x56, 0xb2, 0xbe, 0xe3, 0x51, 0xff, 0xca, 0x08,
-	0xd9, 0xb5, 0x6f, 0x4a, 0x30, 0xcd, 0x49, 0xcc, 0x89, 0xec, 0xb1, 0x25, 0x36, 0x30, 0xfb, 0x44,
-	0xab, 0x50, 0xe5, 0x57, 0x97, 0x19, 0x50, 0x5f, 0x38, 0x77, 0xff, 0x9a, 0x51, 0xe1, 0xa4, 0x13,
-	0xea, 0xa3, 0x7b, 0x30, 0x2b, 0xba, 0x1d, 0x8f, 0x3e, 0xdb, 0xe0, 0x67, 0xde, 0xf4, 0xfe, 0x35,
-	0x03, 0x38, 0xf1, 0x80, 0xd1, 0xd0, 0x1a, 0x88, 0x96, 0xd9, 0x22, 0xc4, 0x15, 0x4f, 0xbf, 0xfd,
-	0x6b, 0x86, 0x90, 0xda, 0x24, 0xc4, 0x6d, 0x96, 0xe5, 0x55, 0xa9, 0xcf, 0xc3, 0x5c, 0xcc, 0x54,
-	0xb9, 0x44, 0x36, 0xcc, 0x6f, 0x63, 0x17, 0x53, 0x3c, 0x2e, 0x3f, 0x21, 0x98, 0x3a, 0xc7, 0x57,
-	0xc2, 0x49, 0x55, 0x83, 0x7f, 0xeb, 0x8b, 0xb0, 0x90, 0x54, 0x22, 0x95, 0x3b, 0x2c, 0xb9, 0x0b,
-	0x28, 0xf1, 0xf1, 0xd6, 0x20, 0xa0, 0xa4, 0xb7, 0x4f, 0xc8, 0x79, 0x30, 0x16, 0x13, 0x78, 0x34,
-	0x4c, 0xc4, 0xa2, 0x61, 0x05, 0xb4, 0x3c, 0x55, 0xd2, 0x90, 0x53, 0x68, 0x34, 0x2d, 0xfb, 0x7c,
-	0xd0, 0x1f, 0xa7, 0x1d, 0xfa, 0x13, 0x58, 0xce, 0x91, 0x3a, 0x24, 0x64, 0xdf, 0xc0, 0xbd, 0xbc,
-	0x2d, 0x35, 0xa6, 0xdd, 0x93, 0xeb, 0x97, 0x07, 0xa0, 0x0f, 0x53, 0x29, 0xfd, 0x73, 0x08, 0x88,
-	0xdd, 0x49, 0x2f, 0x1d, 0x1b, 0x7b, 0x63, 0xb8, 0x01, 0xf5, 0x2d, 0x98, 0x4f, 0xc8, 0x93, 0x3e,
-	0x79, 0x0c, 0xc8, 0x15, 0x24, 0x33, 0xe8, 0x12, 0x9f, 0x9a, 0x9e, 0xd5, 0x0b, 0xef, 0xbb, 0xba,
-	0xec, 0x39, 0x61, 0x1d, 0x87, 0x56, 0x8f, 0x2f, 0xda, 0x1e, 0xa6, 0x07, 0x5e, 0x87, 0x6c, 0x8e,
-	0x2f, 0x01, 0xd4, 0x7f, 0x06, 0xcb, 0x39, 0x52, 0xa5, 0x81, 0x77, 0x00, 0x54, 0xe6, 0x27, 0x97,
-	0x2e, 0x46, 0x61, 0x26, 0x6d, 0x59, 0xae, 0x3d, 0x70, 0x2d, 0x8a, 0xb7, 0xba, 0xd8, 0x3e, 0x0f,
-	0x06, 0xbd, 0xd1, 0x4d, 0xfa, 0x7f, 0x58, 0xce, 0x91, 0x2a, 0x4d, 0xd2, 0xa0, 0x62, 0x4b, 0x9a,
-	0xf4, 0x54, 0xd4, 0x66, 0xcb, 0xb6, 0x87, 0xe9, 0x89, 0x67, 0xf5, 0x83, 0x2e, 0x19, 0x1d, 0x92,
-	0xd0, 0xdf, 0x83, 0xf9, 0x84, 0xbc, 0x21, 0xa1, 0xfc, 0x5d, 0x09, 0xee, 0xe7, 0x05, 0xd6, 0xd8,
-	0x8c, 0x61, 0x39, 0x68, 0x97, 0xd2, 0xbe, 0xa9, 0xae, 0xa5, 0x32, 0x6b, 0x7f, 0xea, 0xbb, 0xec,
-	0x92, 0xe5, 0x5d, 0xd6, 0x80, 0x76, 0x65, 0x5a, 0xc5, 0x79, 0x37, 0x07, 0xb4, 0xab, 0x3f, 0x84,
-	0x07, 0xc3, 0x0d, 0x93, 0x31, 0xff, 0xc7, 0x12, 0x2c, 0xec, 0x61, 0x6a, 0x58, 0x97, 0x5b, 0x5d,
-	0xcb, 0x3b, 0x1b, 0x07, 0xb8, 0x70, 0x1f, 0xae, 0x77, 0x7c, 0xd2, 0x33, 0x13, 0x08, 0x43, 0xd5,
-	0xa8, 0x31, 0x62, 0xf4, 0x4a, 0x5d, 0x83, 0x59, 0x4a, 0xcc, 0xc4, 0x3b, 0xb7, 0x6a, 0x00, 0x25,
-	0x21, 0x83, 0xfe, 0xf7, 0x29, 0xb8, 0x95, 0x32, 0x4c, 0x2e, 0xc4, 0x3e, 0xcc, 0xfa, 0xd6, 0xa5,
-	0x69, 0x0b, 0x72, 0xa3, 0xc4, 0xef, 0xa9, 0x77, 0x63, 0x89, 0x63, 0x76, 0xcc, 0x7a, 0x44, 0x32,
-	0xc0, 0x8f, 0x7a, 0xb5, 0xef, 0x27, 0xa1, 0x1a, 0xf5, 0xa0, 0x25, 0x28, 0xb7, 0x5c, 0xd2, 0x62,
-	0x4f, 0x16, 0x11, 0x62, 0x33, 0xac, 0x79, 0xd0, 0x8e, 0x80, 0x99, 0x09, 0x05, 0xcc, 0xa0, 0x55,
-	0xa8, 0x78, 0xf8, 0xd2, 0xe4, 0x29, 0x28, 0x37, 0xbe, 0x39, 0xd1, 0x28, 0x19, 0x65, 0x0f, 0x5f,
-	0x1e, 0x5b, 0x94, 0xa5, 0x39, 0x15, 0xf6, 0x4e, 0xe7, 0xdd, 0x53, 0xaa, 0x9b, 0xb8, 0x6d, 0xde,
-	0x7d, 0x04, 0x55, 0xd2, 0xc7, 0xbe, 0x45, 0xd9, 0xdc, 0xa7, 0x79, 0xe6, 0xfb, 0xd1, 0x5b, 0x4e,
-	0x60, 0xfd, 0x28, 0x1c, 0x68, 0x28, 0x19, 0xcc, 0xe7, 0xcc, 0x27, 0x4a, 0xa8, 0x80, 0x3a, 0x6a,
-	0xbe, 0x75, 0x19, 0xf1, 0xb3, 0x58, 0x62, 0x46, 0xf5, 0x48, 0x1b, 0x73, 0xb4, 0x63, 0x9a, 0x1b,
-	0xf4, 0x8a, 0xb4, 0x31, 0x87, 0x3a, 0xf0, 0xa5, 0xe8, 0xaa, 0x88, 0x2e, 0x0f, 0x5f, 0xf2, 0xae,
-	0x07, 0x70, 0x23, 0x9c, 0xa9, 0xd9, 0xba, 0x62, 0x27, 0x42, 0x55, 0xe4, 0x75, 0x72, 0xae, 0x4d,
-	0x46, 0x63, 0x5c, 0xe1, 0x84, 0x25, 0x17, 0x08, 0x2e, 0x39, 0x65, 0xce, 0xa5, 0x3b, 0x50, 0x55,
-	0xe6, 0xcc, 0x42, 0xf9, 0xd3, 0xc3, 0x17, 0x87, 0x47, 0x9f, 0x1d, 0xd6, 0xaf, 0xa1, 0x2a, 0x4c,
-	0x6f, 0x6e, 0x6f, 0xef, 0x6c, 0x8b, 0x4c, 0x7d, 0xeb, 0xe8, 0xf8, 0x60, 0x67, 0x5b, 0x64, 0xea,
-	0xdb, 0x3b, 0x2f, 0x77, 0x4e, 0x77, 0xb6, 0xeb, 0x93, 0xa8, 0x06, 0x95, 0x57, 0x47, 0xdb, 0x07,
-	0xbb, 0xac, 0x6b, 0x8a, 0x75, 0x19, 0x3b, 0x87, 0x9b, 0xaf, 0x76, 0xb6, 0xeb, 0xd3, 0xa8, 0x0e,
-	0xb5, 0xd3, 0xcf, 0x8f, 0x77, 0xcc, 0xad, 0xfd, 0xcd, 0xc3, 0xbd, 0x9d, 0xed, 0xfa, 0x8c, 0xfe,
-	0x6b, 0x68, 0x9c, 0x60, 0xcb, 0xb7, 0xbb, 0xbb, 0x8e, 0x8b, 0x83, 0xe6, 0x15, 0x3b, 0x4c, 0x47,
-	0x8f, 0xed, 0x05, 0x98, 0x7e, 0x33, 0xc0, 0x32, 0x5b, 0xa8, 0x1a, 0xa2, 0x11, 0xe6, 0x70, 0x93,
-	0x51, 0x0e, 0xa7, 0x7f, 0x04, 0xcb, 0x39, 0xda, 0x55, 0x5a, 0xd9, 0x61, 0x64, 0x1e, 0xba, 0x35,
-	0x43, 0x34, 0xf4, 0xbf, 0x96, 0xe0, 0x76, 0x62, 0xcc, 0x16, 0xf1, 0x28, 0xf6, 0xe8, 0x8f, 0x66,
-	0x34, 0x7a, 0x0f, 0xea, 0x76, 0x77, 0xe0, 0x9d, 0x63, 0x96, 0x60, 0x0a, 0x5b, 0x25, 0xca, 0x76,
-	0x53, 0xd2, 0xa3, 0x63, 0xe3, 0x0a, 0x56, 0xf2, 0x6d, 0x95, 0x53, 0x6c, 0x40, 0xb9, 0x67, 0x51,
-	0xbb, 0x1b, 0x4d, 0x32, 0x6c, 0xa2, 0x55, 0x00, 0xfe, 0x69, 0xc6, 0x2e, 0xe9, 0x2a, 0xa7, 0x6c,
-	0x5b, 0xd4, 0x42, 0x77, 0xa1, 0x86, 0xbd, 0xb6, 0x49, 0x3a, 0x26, 0xa7, 0x49, 0xf4, 0x0f, 0xb0,
-	0xd7, 0x3e, 0xea, 0xbc, 0x62, 0x14, 0xfd, 0xf7, 0x25, 0x98, 0x11, 0xd8, 0x59, 0xf8, 0x5c, 0x2f,
-	0x45, 0xcf, 0x75, 0xb6, 0x55, 0xf9, 0x6d, 0x2a, 0x66, 0xca, 0xbf, 0xd1, 0x4f, 0x61, 0x39, 0x3a,
-	0x27, 0x89, 0xef, 0x7c, 0xcd, 0xa3, 0xcf, 0xec, 0x62, 0xab, 0x8d, 0x7d, 0x79, 0xf0, 0x2c, 0x85,
-	0xe7, 0x66, 0xd4, 0xbf, 0xcf, 0xbb, 0xd1, 0x3b, 0x70, 0xa3, 0xe7, 0xb0, 0xac, 0xdf, 0xf4, 0x71,
-	0xa7, 0x67, 0xf5, 0x83, 0xc6, 0x14, 0x7f, 0xf1, 0x5d, 0x17, 0x54, 0x43, 0x10, 0xf5, 0x3f, 0x94,
-	0x60, 0x91, 0xe3, 0x16, 0xfb, 0xa7, 0xa7, 0xc7, 0xe3, 0x42, 0x46, 0x1f, 0x26, 0x90, 0xd1, 0x2c,
-	0xb8, 0x18, 0x22, 0xa5, 0x31, 0xe8, 0x73, 0x32, 0x01, 0x7d, 0xea, 0xcb, 0xb0, 0x94, 0xb1, 0x4a,
-	0x2e, 0xe0, 0xe7, 0xb0, 0xba, 0x87, 0xe9, 0x51, 0xeb, 0x57, 0xd8, 0xa6, 0xdb, 0x8e, 0x8f, 0xed,
-	0xf1, 0x21, 0xdc, 0xff, 0x07, 0x77, 0x8a, 0x44, 0x0f, 0x41, 0xba, 0xff, 0x5c, 0x82, 0x85, 0x2d,
-	0x97, 0x78, 0x98, 0x5d, 0x53, 0xc7, 0x84, 0xb8, 0xe3, 0x70, 0xe0, 0x54, 0x9f, 0xa5, 0x0b, 0xa9,
-	0xcc, 0x5e, 0x58, 0xc6, 0x55, 0xf0, 0xfe, 0x98, 0xa3, 0x27, 0x87, 0x39, 0x5a, 0x5f, 0x82, 0x5b,
-	0x29, 0x0b, 0xa5, 0x33, 0xff, 0x59, 0x82, 0x95, 0x44, 0xcf, 0x81, 0x47, 0xb1, 0xef, 0x59, 0x3f,
-	0xe2, 0x1c, 0x72, 0x21, 0x8d, 0xc9, 0xff, 0x02, 0xd2, 0x58, 0x83, 0xd5, 0x82, 0x29, 0x28, 0x80,
-	0x9a, 0xf9, 0xe3, 0x62, 0xdc, 0x00, 0x75, 0x56, 0xa8, 0x54, 0xf8, 0x15, 0x53, 0xe8, 0xf1, 0x83,
-	0x73, 0x6c, 0x0a, 0xf9, 0x45, 0x89, 0x5d, 0x8b, 0x3a, 0x17, 0x58, 0xdc, 0xce, 0xf2, 0x71, 0x12,
-	0x12, 0xd9, 0x5d, 0x25, 0xac, 0x4a, 0x6b, 0x96, 0x56, 0xfd, 0xae, 0xc4, 0x72, 0xac, 0xbe, 0xeb,
-	0xd8, 0xe3, 0xc5, 0xea, 0xd1, 0xfb, 0x30, 0x23, 0x16, 0x65, 0x08, 0x12, 0x25, 0x39, 0xf4, 0x55,
-	0xb8, 0x9d, 0x6b, 0x83, 0xb0, 0x71, 0xe3, 0x2f, 0xab, 0xbc, 0x64, 0x18, 0x16, 0x99, 0x44, 0x7d,
-	0x15, 0x7d, 0x01, 0xf5, 0x74, 0xb9, 0x13, 0xad, 0x65, 0x95, 0x24, 0xaa, 0xab, 0xda, 0xdd, 0x62,
-	0x06, 0xe9, 0x90, 0x99, 0x7f, 0x7f, 0xf7, 0x68, 0xa2, 0x32, 0x81, 0xbe, 0x0c, 0xcb, 0x94, 0xb1,
-	0x1a, 0x26, 0x8a, 0x0f, 0xcf, 0x2d, 0x9a, 0x6a, 0xf7, 0x86, 0x70, 0x24, 0x34, 0x94, 0xd0, 0x0b,
-	0x00, 0x55, 0x94, 0x44, 0xcb, 0xc9, 0x81, 0xb1, 0xe2, 0xa8, 0xa6, 0xe5, 0x75, 0xa5, 0x84, 0x7d,
-	0x06, 0x37, 0x92, 0x35, 0x45, 0xb4, 0x1a, 0xbd, 0xc0, 0xf2, 0x6a, 0x9c, 0xda, 0x9d, 0xa2, 0xee,
-	0xac, 0xe0, 0x64, 0x81, 0x4f, 0x09, 0xce, 0xad, 0x25, 0x2a, 0xc1, 0xf9, 0x75, 0xc1, 0x48, 0xb0,
-	0x0d, 0x28, 0x5b, 0x98, 0x43, 0x91, 0xff, 0x0a, 0xeb, 0x84, 0x9a, 0x3e, 0x8c, 0x25, 0xa5, 0xe4,
-	0x10, 0x66, 0x63, 0xd5, 0x29, 0x14, 0x79, 0x32, 0x5b, 0xf3, 0xd3, 0x6e, 0xe7, 0xf6, 0xa5, 0xe4,
-	0x7d, 0x01, 0xf5, 0x74, 0x1e, 0xa2, 0x82, 0xae, 0xa0, 0xe0, 0xa5, 0x82, 0xae, 0xb0, 0x78, 0x15,
-	0x8a, 0x7f, 0x05, 0xa0, 0x8a, 0x37, 0x2a, 0x24, 0x32, 0xd5, 0x23, 0x15, 0x12, 0xd9, 0x5a, 0x4f,
-	0x28, 0xec, 0x29, 0xb7, 0x36, 0x5d, 0x8c, 0x51, 0xd6, 0x16, 0xd4, 0x7e, 0x94, 0xb5, 0x45, 0x75,
-	0x9c, 0xf8, 0x16, 0xc9, 0x54, 0x37, 0xd4, 0x16, 0x29, 0xaa, 0xe9, 0xa8, 0x2d, 0x52, 0x58, 0x1a,
-	0x89, 0xfc, 0xf1, 0x13, 0x98, 0xda, 0x0d, 0xec, 0x73, 0x34, 0x1f, 0x0d, 0x51, 0x85, 0x11, 0x6d,
-	0x21, 0x49, 0x4c, 0x0d, 0xdd, 0x81, 0x4a, 0x58, 0x1b, 0x40, 0x4b, 0x21, 0x67, 0xaa, 0xce, 0xa1,
-	0x35, 0xb2, 0x1d, 0x29, 0x31, 0xa7, 0x70, 0x3d, 0x01, 0xec, 0xa3, 0x95, 0x48, 0x6b, 0x4e, 0x7d,
-	0x41, 0x5b, 0x2d, 0xe8, 0x4d, 0x79, 0xee, 0x05, 0x80, 0x02, 0xdc, 0xd5, 0x3a, 0x67, 0x8a, 0x02,
-	0x6a, 0x9d, 0x73, 0xf0, 0xf9, 0xd8, 0x46, 0xca, 0x62, 0xe6, 0x6a, 0x23, 0x15, 0x62, 0xf8, 0x6a,
-	0x23, 0x15, 0x43, 0xee, 0x91, 0xc5, 0x5c, 0x49, 0x1a, 0xe5, 0x8e, 0x2b, 0x29, 0x40, 0xdd, 0xe3,
-	0x4a, 0x8a, 0x40, 0xf2, 0x48, 0x89, 0x9f, 0x2d, 0x1a, 0x4b, 0x74, 0x1a, 0x3d, 0x2c, 0xda, 0x43,
-	0x49, 0xb0, 0x5c, 0x7b, 0xf7, 0x07, 0xf9, 0x52, 0xde, 0x3b, 0x81, 0x5a, 0x1c, 0x9d, 0x46, 0xb7,
-	0x93, 0x02, 0x12, 0x30, 0x9e, 0xb6, 0x92, 0xdf, 0x99, 0x9c, 0xc6, 0xd3, 0x12, 0xfa, 0x0d, 0x68,
-	0xc5, 0x00, 0x1d, 0x7a, 0x6f, 0x98, 0x8d, 0x49, 0x85, 0xef, 0xbf, 0x0d, 0x6b, 0x72, 0x46, 0x8f,
-	0x4a, 0x68, 0x1f, 0xaa, 0x11, 0x68, 0x8c, 0x1a, 0x45, 0x90, 0xb7, 0xb6, 0x9c, 0xd3, 0x93, 0xf2,
-	0xce, 0x27, 0x50, 0x8b, 0x83, 0xc0, 0xca, 0x3b, 0x39, 0xf8, 0xb3, 0xf2, 0x4e, 0x2e, 0x6e, 0x1c,
-	0x3f, 0x92, 0x15, 0x8c, 0x18, 0x3b, 0x92, 0x33, 0x58, 0x65, 0xec, 0x48, 0xce, 0xe2, 0x8e, 0x51,
-	0xd0, 0xb4, 0x78, 0xdd, 0x3f, 0x89, 0xfd, 0xa1, 0x78, 0xe1, 0x3d, 0x17, 0x6c, 0x54, 0xa7, 0x50,
-	0x21, 0x70, 0x18, 0x5b, 0xcf, 0x2f, 0x61, 0x2e, 0x03, 0xe6, 0x29, 0x1d, 0x45, 0xe8, 0xa1, 0xd2,
-	0x51, 0x88, 0x04, 0x46, 0xb3, 0x68, 0x42, 0x59, 0xfe, 0xad, 0x83, 0x16, 0xa3, 0x51, 0x89, 0x5f,
-	0x81, 0xb4, 0xa5, 0x0c, 0x3d, 0xe5, 0xd9, 0x63, 0x98, 0x8d, 0x21, 0x7d, 0x28, 0x7e, 0x47, 0xa4,
-	0x10, 0x3c, 0xe5, 0xd9, 0x1c, 0x68, 0x30, 0x36, 0xef, 0xdf, 0xb2, 0x4c, 0x60, 0x08, 0xee, 0x86,
-	0x3e, 0x18, 0x16, 0x9f, 0x69, 0xa5, 0x8f, 0xdf, 0x8e, 0x39, 0x35, 0xab, 0x5f, 0xc2, 0xf5, 0x04,
-	0x86, 0xa4, 0x4e, 0xe0, 0x3c, 0xa0, 0x4f, 0x9d, 0xc0, 0xb9, 0xc0, 0x53, 0x6c, 0x6e, 0xe7, 0xb0,
-	0x90, 0x97, 0xf3, 0xa3, 0xfb, 0x6a, 0x57, 0x14, 0xa2, 0x17, 0xda, 0x83, 0xe1, 0x4c, 0x19, 0x65,
-	0x2d, 0x98, 0xcb, 0x00, 0x28, 0x2a, 0x80, 0x8a, 0x90, 0x1d, 0x15, 0x40, 0x85, 0xe8, 0x4b, 0x4c,
-	0x07, 0x06, 0x94, 0xad, 0x96, 0xa0, 0xd8, 0x83, 0xb4, 0xa0, 0x68, 0xa3, 0x8e, 0xe8, 0x21, 0xc5,
-	0x16, 0x75, 0xb8, 0xb4, 0x60, 0x2e, 0x53, 0x20, 0x51, 0x53, 0x29, 0xaa, 0xc8, 0xa8, 0xa9, 0x14,
-	0x56, 0x57, 0x62, 0x53, 0x79, 0x0d, 0x37, 0x53, 0x99, 0x3e, 0xba, 0x93, 0x78, 0x35, 0x64, 0x80,
-	0x09, 0x6d, 0xad, 0xb0, 0x3f, 0x15, 0x4f, 0x04, 0x16, 0xf3, 0xf3, 0x79, 0xf4, 0x4e, 0x2c, 0x74,
-	0x8a, 0xa1, 0x04, 0xed, 0xe1, 0x0f, 0xb1, 0xa5, 0xb6, 0xf6, 0x29, 0x5c, 0x4f, 0xa4, 0xa2, 0x2a,
-	0x80, 0xf3, 0x00, 0x02, 0x15, 0xc0, 0xf9, 0xc9, 0x79, 0x38, 0x0d, 0x37, 0x95, 0xbd, 0x87, 0x09,
-	0x2e, 0x7a, 0x90, 0x3b, 0x3e, 0x95, 0xc2, 0x6b, 0xef, 0xfc, 0x00, 0x57, 0xf6, 0xdd, 0x9b, 0x4e,
-	0x6c, 0xe3, 0xc9, 0x56, 0x6e, 0x1e, 0x1d, 0x4f, 0xb6, 0x0a, 0x72, 0xe2, 0x84, 0xf8, 0x64, 0x86,
-	0x1a, 0x17, 0x9f, 0x9b, 0x35, 0xc7, 0xc5, 0x17, 0x24, 0xb7, 0xa1, 0xf8, 0x0e, 0xcc, 0xe7, 0xe4,
-	0x97, 0x28, 0x16, 0xf7, 0x45, 0x09, 0xb0, 0x76, 0x7f, 0x28, 0x4f, 0x52, 0x4f, 0xf3, 0xe9, 0x6b,
-	0xc6, 0xed, 0x5a, 0xad, 0x75, 0x9b, 0xf4, 0x9e, 0x88, 0xcf, 0x0f, 0x89, 0x7f, 0xf6, 0x44, 0xc8,
-	0x78, 0xc2, 0x7f, 0xfe, 0x7d, 0x72, 0x46, 0x64, 0xbb, 0xdf, 0x6a, 0xcd, 0x70, 0xd2, 0xb3, 0xff,
-	0x04, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x53, 0xac, 0x6d, 0x41, 0x2c, 0x00, 0x00,
+	// 2961 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0x4b, 0x6f, 0x1c, 0xc7,
+	0xf1, 0xd7, 0xf2, 0xb5, 0xbb, 0xc5, 0x95, 0xb4, 0x6c, 0x52, 0xe2, 0x72, 0x24, 0x8a, 0xd2, 0x48,
+	0x96, 0x65, 0x5b, 0xa6, 0x64, 0xe9, 0x0f, 0xfc, 0x9d, 0x04, 0x41, 0xc0, 0x37, 0xa9, 0x07, 0x49,
+	0x0f, 0xe9, 0x18, 0x16, 0x60, 0x8c, 0x67, 0x67, 0x9b, 0xdc, 0x09, 0x67, 0xa7, 0x57, 0x3d, 0xbd,
+	0xa4, 0x68, 0x24, 0x87, 0x04, 0xf0, 0xd5, 0x40, 0x80, 0x20, 0xce, 0x31, 0xe7, 0x9c, 0x73, 0xc8,
+	0x25, 0x08, 0x72, 0xc9, 0x77, 0xf0, 0xe7, 0xc8, 0x2d, 0xa7, 0xa0, 0x1f, 0x33, 0x3d, 0xcf, 0xb5,
+	0x02, 0x2e, 0x1c, 0xe4, 0x36, 0x5d, 0x5d, 0x5d, 0x55, 0x5d, 0x5d, 0xfd, 0xa8, 0x5f, 0x0d, 0xb4,
+	0x28, 0xee, 0x93, 0xd0, 0x63, 0x84, 0x9e, 0x7f, 0x18, 0x62, 0x7a, 0xea, 0xb9, 0x78, 0xb9, 0x4f,
+	0x09, 0x23, 0x68, 0xea, 0xd8, 0x63, 0x8e, 0x7f, 0x6e, 0x34, 0xc2, 0xae, 0x43, 0x71, 0x47, 0x52,
+	0xcd, 0x03, 0x98, 0xb7, 0xe2, 0x11, 0x1b, 0x6f, 0xbc, 0x90, 0x85, 0x16, 0x7e, 0x3d, 0xc0, 0x21,
+	0x43, 0x1f, 0x03, 0x68, 0x61, 0xad, 0xca, 0xed, 0xca, 0x83, 0xe9, 0x27, 0x68, 0x59, 0x4a, 0x59,
+	0xd6, 0x83, 0x56, 0x27, 0xfe, 0xf0, 0x8f, 0x87, 0x15, 0x2b, 0xc1, 0x6b, 0x3e, 0x81, 0x56, 0x5e,
+	0x68, 0xd8, 0x27, 0x41, 0x88, 0xd1, 0x75, 0x98, 0xc2, 0x82, 0x22, 0x24, 0xd6, 0x2c, 0xd5, 0x32,
+	0x0f, 0xc5, 0x18, 0xc7, 0x3d, 0xd9, 0x09, 0x5c, 0x8a, 0x7b, 0x38, 0x60, 0x8e, 0x7f, 0x71, 0x4b,
+	0x6e, 0xc0, 0x42, 0x81, 0x54, 0x69, 0x8a, 0x49, 0x61, 0x46, 0x76, 0x6e, 0x0e, 0xfc, 0x8b, 0xeb,
+	0x42, 0x77, 0xe1, 0xb2, 0x4b, 0xb1, 0xc3, 0xb0, 0xdd, 0xf6, 0x58, 0xcf, 0xe9, 0xb7, 0xc6, 0xc4,
+	0x04, 0x1b, 0x92, 0xb8, 0x2a, 0x68, 0xe6, 0x1c, 0xa0, 0xa4, 0x4e, 0x65, 0xc9, 0x29, 0x5c, 0xdb,
+	0x72, 0x68, 0xdb, 0x39, 0xc6, 0x6b, 0xc4, 0xf7, 0xb1, 0xcb, 0x7e, 0x20, 0x6b, 0x5a, 0x70, 0x3d,
+	0xab, 0x57, 0x59, 0xf4, 0x0c, 0xae, 0xac, 0xf9, 0xd8, 0x09, 0x06, 0xfd, 0x8b, 0x2f, 0xc2, 0x0c,
+	0x5c, 0x8d, 0x65, 0x29, 0xf1, 0x9f, 0xc0, 0x35, 0x3d, 0xe4, 0xc0, 0xfb, 0x0a, 0x5f, 0x5c, 0xcb,
+	0x43, 0xb8, 0x9e, 0x15, 0xa9, 0x42, 0x0e, 0xc1, 0x44, 0xe8, 0x7d, 0x85, 0x85, 0xb4, 0x71, 0x4b,
+	0x7c, 0x9b, 0xaf, 0x61, 0x61, 0xa5, 0xdf, 0xf7, 0xcf, 0xb7, 0x3c, 0xe6, 0x30, 0x46, 0xbd, 0xf6,
+	0x80, 0xe1, 0x8b, 0x47, 0x3e, 0x32, 0xa0, 0x46, 0xf1, 0xa9, 0x17, 0x7a, 0x24, 0x10, 0x0e, 0x6f,
+	0x58, 0x71, 0xdb, 0xbc, 0x09, 0x46, 0x91, 0x4a, 0xe5, 0x91, 0xbf, 0x8d, 0x01, 0xda, 0xc4, 0xcc,
+	0xed, 0x5a, 0xb8, 0x47, 0xd8, 0xc5, 0xfd, 0xc1, 0x37, 0x1a, 0x15, 0xa2, 0x84, 0x21, 0x75, 0x4b,
+	0xb5, 0xd0, 0x1c, 0x4c, 0x1e, 0x11, 0xea, 0xe2, 0xd6, 0xb8, 0x08, 0x08, 0xd9, 0x40, 0xf3, 0x50,
+	0x0d, 0x88, 0xcd, 0x9c, 0xe3, 0xb0, 0x35, 0x21, 0xf7, 0x65, 0x40, 0x0e, 0x9d, 0xe3, 0x10, 0xb5,
+	0xa0, 0xca, 0xbc, 0x1e, 0x26, 0x03, 0xd6, 0x9a, 0xbc, 0x5d, 0x79, 0x30, 0x69, 0x45, 0x4d, 0x3e,
+	0x24, 0x0c, 0xbb, 0xf6, 0x09, 0x3e, 0x6f, 0x4d, 0x49, 0x0d, 0x61, 0xd8, 0x7d, 0x8e, 0xcf, 0xd1,
+	0x12, 0x4c, 0x9f, 0x04, 0xe4, 0x2c, 0xb0, 0xbb, 0x84, 0xef, 0xf3, 0xaa, 0xe8, 0x04, 0x41, 0xda,
+	0xe6, 0x14, 0xb4, 0x00, 0xb5, 0x80, 0xd8, 0x7d, 0x3a, 0x08, 0x70, 0xab, 0x2e, 0xb4, 0x55, 0x03,
+	0xb2, 0xcf, 0x9b, 0xe8, 0x29, 0x5c, 0x96, 0x76, 0xda, 0x7d, 0x87, 0x3a, 0xbd, 0xb0, 0x05, 0x62,
+	0xca, 0x57, 0xf4, 0x94, 0x85, 0x77, 0x1a, 0x92, 0x69, 0x5f, 0xf0, 0x3c, 0x9b, 0xa8, 0xd5, 0x9a,
+	0x75, 0xf3, 0x1a, 0xcc, 0xa6, 0x1c, 0xa8, 0x1c, 0x7b, 0x00, 0xf3, 0x6b, 0x22, 0xe6, 0xb5, 0xb7,
+	0x2e, 0x1e, 0x6c, 0x06, 0xb4, 0xf2, 0x42, 0x95, 0xc2, 0xaf, 0xc7, 0x60, 0x66, 0x0b, 0xb3, 0x15,
+	0xea, 0x76, 0xbd, 0xd3, 0x11, 0x2c, 0xe4, 0x0d, 0xa8, 0xbb, 0xa4, 0xd7, 0xf3, 0x98, 0xed, 0x75,
+	0xd4, 0x5a, 0xd6, 0x24, 0x61, 0xa7, 0xc3, 0x57, 0xb9, 0x4f, 0xf1, 0x91, 0xf7, 0x46, 0x2c, 0x67,
+	0xdd, 0x52, 0x2d, 0xf4, 0x31, 0x4c, 0x1d, 0x11, 0xda, 0x73, 0x98, 0x58, 0xce, 0x2b, 0x4f, 0x6e,
+	0x47, 0xaa, 0x72, 0x96, 0x2d, 0x6f, 0x0a, 0x3e, 0x4b, 0xf1, 0xf3, 0xdd, 0xd2, 0x77, 0x58, 0x57,
+	0xac, 0x76, 0xc3, 0x12, 0xdf, 0xe6, 0x53, 0x98, 0x92, 0x5c, 0xa8, 0x0a, 0xe3, 0xaf, 0x76, 0xf6,
+	0x9b, 0x97, 0xf8, 0xc7, 0xe1, 0x8a, 0xd5, 0xac, 0x20, 0x80, 0xa9, 0xc3, 0x15, 0xcb, 0xde, 0x7a,
+	0xd5, 0x1c, 0x43, 0xd3, 0x50, 0xe5, 0xdf, 0xab, 0xaf, 0x9e, 0x34, 0xc7, 0xcd, 0x07, 0x80, 0x92,
+	0xca, 0xf4, 0x66, 0xec, 0x38, 0xcc, 0x11, 0x1e, 0x68, 0x58, 0xe2, 0x9b, 0x2f, 0xd1, 0xb6, 0x13,
+	0xbe, 0x20, 0xae, 0xe3, 0xaf, 0x52, 0x27, 0x70, 0xbb, 0x23, 0xd8, 0x8a, 0xe6, 0x63, 0x68, 0xe5,
+	0x85, 0x2a, 0x23, 0xe6, 0x60, 0xf2, 0xd4, 0xf1, 0x07, 0x58, 0xdd, 0x41, 0xb2, 0x61, 0x7e, 0x57,
+	0x81, 0x96, 0x88, 0xa0, 0x03, 0x32, 0xa0, 0x2e, 0x96, 0xa3, 0x2e, 0xbe, 0x7e, 0x3f, 0x83, 0x99,
+	0x50, 0x08, 0xb4, 0x13, 0x02, 0xc6, 0xca, 0x04, 0x58, 0x4d, 0xc9, 0x6c, 0xa5, 0x8e, 0x72, 0x25,
+	0xa0, 0x2d, 0x4c, 0x12, 0x4b, 0xdd, 0xb0, 0x1a, 0x61, 0xc2, 0x4c, 0xb4, 0x08, 0xc0, 0x1c, 0x7a,
+	0x8c, 0x99, 0x4d, 0xf1, 0x91, 0x58, 0xf4, 0x86, 0x55, 0x97, 0x14, 0x0b, 0x1f, 0x99, 0x4f, 0x61,
+	0xa1, 0x60, 0x6a, 0xfa, 0x4e, 0xa6, 0x38, 0x1c, 0xf8, 0x2c, 0xba, 0x93, 0x65, 0xcb, 0xdc, 0x82,
+	0xe9, 0xcd, 0xd0, 0x3d, 0xb9, 0xf8, 0x5a, 0xdc, 0x83, 0x86, 0x14, 0xa4, 0xfd, 0x8f, 0x29, 0x25,
+	0x54, 0x45, 0x81, 0x6c, 0x98, 0x7f, 0xa9, 0xc0, 0xd5, 0xcf, 0xa8, 0xc7, 0x37, 0xd5, 0xd1, 0xc5,
+	0xdd, 0xde, 0x84, 0x71, 0xee, 0x09, 0x79, 0x0a, 0xf3, 0xcf, 0xd4, 0xe1, 0x3c, 0x9e, 0x3e, 0x9c,
+	0xd1, 0x1d, 0x68, 0x10, 0xbf, 0x63, 0xc7, 0xfd, 0xd2, 0x81, 0xd3, 0xc4, 0xef, 0x58, 0x11, 0x4b,
+	0x7c, 0x70, 0x4e, 0x26, 0x0e, 0xce, 0x67, 0x13, 0xb5, 0xa9, 0x66, 0xd5, 0x6c, 0x41, 0x53, 0x5b,
+	0x2e, 0x27, 0xf9, 0x6c, 0xa2, 0x56, 0x69, 0x8e, 0x99, 0x7f, 0xae, 0xc0, 0x4c, 0xd4, 0x75, 0xf8,
+	0xe6, 0x7f, 0x65, 0x5a, 0xfc, 0x9d, 0x92, 0xb4, 0x5a, 0x1d, 0x6d, 0x01, 0xcc, 0x6d, 0x7a, 0x41,
+	0xe7, 0x25, 0xa6, 0xc7, 0x78, 0xd5, 0x09, 0x47, 0x70, 0xb8, 0xdd, 0x84, 0x7a, 0x64, 0x5c, 0xd8,
+	0x1a, 0xbb, 0x3d, 0xce, 0xa3, 0x36, 0x26, 0x98, 0x1f, 0xc0, 0xb5, 0x8c, 0x3e, 0x7d, 0x8a, 0xb4,
+	0x9d, 0x50, 0xee, 0xdf, 0xba, 0x25, 0xbe, 0xcd, 0x6f, 0x2a, 0x30, 0x23, 0x0f, 0xe5, 0x4d, 0x42,
+	0x4f, 0xfe, 0xfb, 0xfb, 0x96, 0xfb, 0x30, 0x69, 0x4f, 0xfc, 0xea, 0x5c, 0xd8, 0x09, 0x2d, 0xcc,
+	0x4d, 0xde, 0x09, 0xf6, 0x29, 0x39, 0xa6, 0x38, 0x0c, 0x47, 0x72, 0x4b, 0x50, 0x21, 0x34, 0x71,
+	0x4b, 0x48, 0xc2, 0x4e, 0xc7, 0xfc, 0x29, 0x18, 0x45, 0x3a, 0x95, 0x33, 0x97, 0x60, 0xda, 0x0b,
+	0xec, 0xbe, 0x22, 0xab, 0x33, 0x00, 0xbc, 0x98, 0x51, 0x9a, 0x7c, 0xf0, 0x7a, 0xe0, 0x84, 0xdd,
+	0x11, 0x9b, 0x1c, 0x0a, 0xa1, 0x09, 0x93, 0x25, 0x21, 0x32, 0x39, 0xaf, 0xf3, 0x6d, 0x4d, 0xf6,
+	0xe1, 0x56, 0xf6, 0x82, 0xde, 0xa4, 0xa4, 0xf7, 0xa9, 0xf5, 0x62, 0x24, 0x5b, 0x70, 0x40, 0x7d,
+	0x65, 0x31, 0xff, 0x34, 0xef, 0xc0, 0x52, 0xa9, 0x36, 0xb5, 0xec, 0x7b, 0x30, 0x2b, 0x59, 0x56,
+	0x07, 0x41, 0xc7, 0x1f, 0xc1, 0x7b, 0xf7, 0x7d, 0x98, 0x4b, 0x0b, 0x1c, 0x72, 0xc1, 0x7e, 0x33,
+	0x06, 0xcd, 0x03, 0xcc, 0xd6, 0x48, 0x70, 0xe4, 0x1d, 0x5f, 0xdc, 0x01, 0x1f, 0x43, 0x15, 0x07,
+	0x8c, 0x7a, 0x58, 0x6e, 0xd9, 0xe9, 0x27, 0xb7, 0xa2, 0x61, 0x59, 0x25, 0xcb, 0x1b, 0x01, 0xa3,
+	0xe7, 0x56, 0xc4, 0x6e, 0x7c, 0x5d, 0x81, 0x49, 0x41, 0xe2, 0x4e, 0xe4, 0x2f, 0x47, 0xb9, 0x81,
+	0xf9, 0x27, 0x5a, 0x84, 0xba, 0xb8, 0x87, 0xed, 0x90, 0x51, 0xe9, 0xdc, 0xed, 0x4b, 0x56, 0x4d,
+	0x90, 0x0e, 0x18, 0x45, 0x77, 0x60, 0x5a, 0x76, 0x7b, 0x01, 0x7b, 0xfa, 0x44, 0x9c, 0x74, 0x93,
+	0xdb, 0x97, 0x2c, 0x10, 0xc4, 0x1d, 0x4e, 0x43, 0x4b, 0x20, 0x5b, 0x76, 0x9b, 0x10, 0x5f, 0xbe,
+	0x63, 0xb7, 0x2f, 0x59, 0x52, 0xea, 0x2a, 0x21, 0xfe, 0x6a, 0x55, 0xdd, 0xfb, 0xe6, 0x2c, 0xcc,
+	0x24, 0x4c, 0x55, 0x4b, 0xe4, 0xc2, 0xec, 0x3a, 0xf6, 0x31, 0xc3, 0xa3, 0xf2, 0x13, 0x82, 0x89,
+	0x13, 0x7c, 0x2e, 0x9d, 0x54, 0xb7, 0xc4, 0xb7, 0x79, 0x1d, 0xe6, 0xd2, 0x4a, 0x94, 0x72, 0x8f,
+	0x67, 0xaa, 0x21, 0x23, 0x14, 0xaf, 0x0d, 0x42, 0x46, 0x7a, 0xdb, 0x84, 0x9c, 0x84, 0x23, 0x31,
+	0x41, 0x44, 0xc3, 0x58, 0x22, 0x1a, 0x6e, 0x82, 0x51, 0xa4, 0x4a, 0x19, 0x72, 0x08, 0xad, 0x55,
+	0xc7, 0x3d, 0x19, 0xf4, 0x47, 0x69, 0x87, 0xf9, 0x08, 0x16, 0x0a, 0xa4, 0x0e, 0x09, 0xd9, 0xd7,
+	0x70, 0xa7, 0x68, 0x4b, 0x8d, 0x68, 0xf7, 0x14, 0xfa, 0xe5, 0x1e, 0x98, 0xc3, 0x54, 0x2a, 0xff,
+	0xec, 0x02, 0xe2, 0x77, 0xd2, 0x0b, 0xcf, 0xc5, 0xc1, 0x08, 0x6e, 0x40, 0x73, 0x0d, 0x66, 0x53,
+	0xf2, 0x94, 0x4f, 0x1e, 0x02, 0xf2, 0x25, 0xc9, 0x0e, 0xbb, 0x84, 0x32, 0x3b, 0x70, 0x7a, 0xd1,
+	0x7d, 0xd7, 0x54, 0x3d, 0x07, 0xbc, 0x63, 0xd7, 0xe9, 0x89, 0x45, 0xdb, 0xc2, 0x6c, 0x27, 0x38,
+	0x22, 0x2b, 0xa3, 0xcb, 0x66, 0xcd, 0x9f, 0xc0, 0x42, 0x81, 0x54, 0x65, 0xe0, 0x2d, 0x00, 0x9d,
+	0xc6, 0xaa, 0xa5, 0x4b, 0x50, 0xb8, 0x49, 0x6b, 0x8e, 0xef, 0x0e, 0x7c, 0x87, 0xe1, 0xb5, 0x2e,
+	0x76, 0x4f, 0xc2, 0x41, 0xef, 0xe2, 0x26, 0xfd, 0x3f, 0x2c, 0x14, 0x48, 0x55, 0x26, 0x19, 0x50,
+	0x73, 0x15, 0x4d, 0x79, 0x2a, 0x6e, 0xf3, 0x65, 0xdb, 0xc2, 0xec, 0x20, 0x70, 0xfa, 0x61, 0x97,
+	0x5c, 0x1c, 0x5f, 0x31, 0xdf, 0x83, 0xd9, 0x94, 0xbc, 0x21, 0xa1, 0xfc, 0x6d, 0x05, 0xee, 0x16,
+	0x05, 0xd6, 0xc8, 0x8c, 0xe1, 0x09, 0x75, 0x97, 0xb1, 0xbe, 0xad, 0xaf, 0xa5, 0x2a, 0x6f, 0x7f,
+	0x4a, 0x7d, 0x7e, 0xc9, 0x8a, 0x2e, 0x67, 0xc0, 0xba, 0x2a, 0x47, 0x14, 0xbc, 0x2b, 0x03, 0xd6,
+	0x35, 0xef, 0xc3, 0xbd, 0xe1, 0x86, 0xa9, 0x98, 0xff, 0x7d, 0x05, 0xe6, 0xb6, 0x30, 0xb3, 0x9c,
+	0xb3, 0xb5, 0xae, 0x13, 0x1c, 0x8f, 0x02, 0x29, 0xb9, 0x0b, 0x97, 0x8f, 0x28, 0xe9, 0xd9, 0x29,
+	0xb8, 0xa4, 0x6e, 0x35, 0x38, 0x31, 0x7e, 0x9b, 0x2e, 0xc1, 0x34, 0x23, 0x76, 0xea, 0x75, 0x5b,
+	0xb7, 0x80, 0x91, 0x88, 0xc1, 0xfc, 0xeb, 0x04, 0x5c, 0xcb, 0x18, 0xa6, 0x16, 0x62, 0x1b, 0xa6,
+	0xa9, 0x73, 0x66, 0xbb, 0x92, 0xdc, 0xaa, 0x88, 0x7b, 0xea, 0xdd, 0x44, 0x16, 0x9c, 0x1f, 0xb3,
+	0x1c, 0x93, 0x2c, 0xa0, 0x71, 0xaf, 0xf1, 0xdd, 0x38, 0xd4, 0xe3, 0x1e, 0x34, 0x0f, 0xd5, 0xb6,
+	0x4f, 0xda, 0xfc, 0xc9, 0x22, 0x43, 0x6c, 0x8a, 0x37, 0x77, 0x3a, 0x31, 0xca, 0x34, 0xa6, 0x51,
+	0x26, 0xb4, 0x08, 0xb5, 0x00, 0x9f, 0xd9, 0x22, 0x9f, 0x16, 0xc6, 0xaf, 0x8e, 0xb5, 0x2a, 0x56,
+	0x35, 0xc0, 0x67, 0xfb, 0x0e, 0xe3, 0x39, 0x5b, 0x8d, 0xbf, 0xce, 0x45, 0xf7, 0x84, 0xee, 0x26,
+	0x7e, 0x47, 0x74, 0xef, 0x41, 0x9d, 0xf4, 0x31, 0x75, 0x18, 0x9f, 0xfb, 0xa4, 0x48, 0xe3, 0x3f,
+	0x7a, 0xcb, 0x09, 0x2c, 0xef, 0x45, 0x03, 0x2d, 0x2d, 0x83, 0xfb, 0x9c, 0xfb, 0x44, 0x0b, 0x95,
+	0xb8, 0x4d, 0x83, 0x3a, 0x67, 0x31, 0x3f, 0x8f, 0x25, 0x6e, 0x54, 0x8f, 0x74, 0xb0, 0x80, 0x6e,
+	0x26, 0x85, 0x41, 0x2f, 0x49, 0x07, 0x0b, 0xdc, 0x06, 0x9f, 0xc9, 0xae, 0x9a, 0xec, 0x0a, 0xf0,
+	0x99, 0xe8, 0xba, 0x07, 0x57, 0xa2, 0x99, 0xda, 0xed, 0x73, 0x7e, 0x22, 0xd4, 0x65, 0x92, 0xaa,
+	0xe6, 0xba, 0xca, 0x69, 0x9c, 0x2b, 0x9a, 0xb0, 0xe2, 0x02, 0xc9, 0xa5, 0xa6, 0x2c, 0xb8, 0x4c,
+	0x0f, 0xea, 0xda, 0x9c, 0x69, 0xa8, 0x7e, 0xba, 0xfb, 0x7c, 0x77, 0xef, 0xb3, 0xdd, 0xe6, 0x25,
+	0x54, 0x87, 0xc9, 0x95, 0xf5, 0xf5, 0x8d, 0x75, 0x09, 0x3b, 0xac, 0xed, 0xed, 0xef, 0x6c, 0xac,
+	0x4b, 0xd8, 0x61, 0x7d, 0xe3, 0xc5, 0xc6, 0xe1, 0xc6, 0x7a, 0x73, 0x1c, 0x35, 0xa0, 0xf6, 0x72,
+	0x6f, 0x7d, 0x67, 0x93, 0x77, 0x4d, 0xf0, 0x2e, 0x6b, 0x63, 0x77, 0xe5, 0xe5, 0xc6, 0x7a, 0x73,
+	0x12, 0x35, 0xa1, 0x71, 0xf8, 0xf9, 0xfe, 0x86, 0xbd, 0xb6, 0xbd, 0xb2, 0xbb, 0xb5, 0xb1, 0xde,
+	0x9c, 0x32, 0x7f, 0x09, 0xad, 0x03, 0xec, 0x50, 0xb7, 0xbb, 0xe9, 0xf9, 0x38, 0x5c, 0x3d, 0xe7,
+	0x87, 0xe9, 0xc5, 0x63, 0x7b, 0x0e, 0x26, 0x5f, 0x0f, 0xb0, 0xca, 0x16, 0xea, 0x96, 0x6c, 0x44,
+	0x99, 0xdb, 0x78, 0x9c, 0xb9, 0x99, 0x1f, 0xc1, 0x42, 0x81, 0x76, 0x9d, 0x23, 0x1f, 0x71, 0xb2,
+	0x08, 0xdd, 0x86, 0x25, 0x1b, 0xe6, 0x9f, 0x2a, 0x70, 0x23, 0x35, 0x66, 0x8d, 0x04, 0x0c, 0x07,
+	0xec, 0x07, 0x33, 0x1a, 0xbd, 0x07, 0x4d, 0xb7, 0x3b, 0x08, 0x4e, 0x30, 0x4f, 0x2b, 0xa5, 0xad,
+	0x0a, 0x32, 0xbc, 0xaa, 0xe8, 0xf1, 0xb1, 0x71, 0x0e, 0x37, 0x8b, 0x6d, 0x55, 0x53, 0x6c, 0x41,
+	0xb5, 0xe7, 0x30, 0xb7, 0x1b, 0x4f, 0x32, 0x6a, 0xa2, 0x45, 0x00, 0xf1, 0x69, 0x27, 0x2e, 0xe9,
+	0xba, 0xa0, 0xac, 0x3b, 0xcc, 0x41, 0xb7, 0xa1, 0x81, 0x83, 0x8e, 0x4d, 0x8e, 0x6c, 0x41, 0x53,
+	0x50, 0x26, 0xe0, 0xa0, 0xb3, 0x77, 0xf4, 0x92, 0x53, 0xcc, 0xdf, 0x56, 0x60, 0x4a, 0x02, 0x81,
+	0xd1, 0x73, 0xbd, 0x12, 0x3f, 0xd7, 0xf9, 0x56, 0x15, 0xb7, 0xa9, 0x9c, 0xa9, 0xf8, 0x46, 0x3f,
+	0x86, 0x85, 0xf8, 0x9c, 0x24, 0xd4, 0xfb, 0x4a, 0x44, 0x9f, 0xdd, 0xc5, 0x4e, 0x07, 0x53, 0x75,
+	0xf0, 0xcc, 0x47, 0xe7, 0x66, 0xdc, 0xbf, 0x2d, 0xba, 0xd1, 0x3b, 0x70, 0xa5, 0xe7, 0x51, 0x4a,
+	0xa8, 0x4d, 0xf1, 0x51, 0xcf, 0xe9, 0x87, 0xad, 0x09, 0xf1, 0xe2, 0xbb, 0x2c, 0xa9, 0x96, 0x24,
+	0x9a, 0xbf, 0xab, 0xc0, 0x75, 0x01, 0xc2, 0x6c, 0x1f, 0x1e, 0xee, 0x8f, 0x0a, 0xe6, 0xbd, 0x9f,
+	0x82, 0x79, 0xf3, 0x48, 0x69, 0x04, 0xfb, 0x26, 0x70, 0xdc, 0xf1, 0x14, 0x8e, 0x6b, 0x2e, 0xc0,
+	0x7c, 0xce, 0x2a, 0xb5, 0x80, 0x9f, 0xc3, 0xe2, 0x16, 0x66, 0x7b, 0xed, 0x5f, 0x60, 0x97, 0xad,
+	0x7b, 0x14, 0xbb, 0xa3, 0x83, 0xeb, 0xff, 0x0f, 0x6e, 0x95, 0x89, 0x1e, 0x02, 0xdb, 0xff, 0xb1,
+	0x02, 0x73, 0x6b, 0x3e, 0x09, 0x30, 0xbf, 0xa6, 0xf6, 0x09, 0xf1, 0x47, 0xe1, 0xc0, 0x89, 0x3e,
+	0x4f, 0x17, 0x32, 0x99, 0xbd, 0xb4, 0x4c, 0xa8, 0x10, 0xfd, 0x09, 0x47, 0x8f, 0x0f, 0x73, 0xb4,
+	0x39, 0x0f, 0xd7, 0x32, 0x16, 0x2a, 0x67, 0xfe, 0xbd, 0x02, 0x37, 0x53, 0x3d, 0x3b, 0x01, 0xc3,
+	0x34, 0x70, 0x7e, 0xc0, 0x39, 0x14, 0x42, 0x1a, 0xe3, 0xff, 0x01, 0xa4, 0xb1, 0x04, 0x8b, 0x25,
+	0x53, 0xd0, 0x68, 0x3b, 0xf7, 0xc7, 0xe9, 0xa8, 0xd1, 0xf6, 0xbc, 0x50, 0xa5, 0xf0, 0x0d, 0x57,
+	0x18, 0x88, 0x83, 0x73, 0x64, 0x0a, 0xc5, 0x45, 0x89, 0x7d, 0x87, 0x79, 0xa7, 0x58, 0xde, 0xce,
+	0xea, 0x71, 0x12, 0x11, 0xf9, 0x5d, 0x25, 0xad, 0xca, 0x6a, 0x56, 0x56, 0xfd, 0xa6, 0xc2, 0x73,
+	0xac, 0xbe, 0xef, 0xb9, 0xa3, 0x2d, 0x3c, 0xa0, 0xf7, 0x61, 0x4a, 0x2e, 0xca, 0x10, 0x24, 0x4a,
+	0x71, 0x98, 0x8b, 0x70, 0xa3, 0xd0, 0x06, 0x69, 0xe3, 0x93, 0x7f, 0x2e, 0x8a, 0xfa, 0x67, 0x54,
+	0x31, 0x93, 0xc5, 0x62, 0xf4, 0x05, 0x34, 0xb3, 0xb5, 0x5b, 0xb4, 0x94, 0x57, 0x92, 0x2a, 0x15,
+	0x1b, 0xb7, 0xcb, 0x19, 0x94, 0x43, 0xa6, 0xfe, 0xf5, 0xed, 0x83, 0xb1, 0xda, 0x18, 0xfa, 0x32,
+	0xaa, 0xb9, 0x26, 0x0a, 0xb2, 0x28, 0x39, 0xbc, 0xb0, 0x02, 0x6c, 0xdc, 0x19, 0xc2, 0x91, 0xd2,
+	0x50, 0x41, 0xcf, 0x01, 0x74, 0x85, 0x15, 0x2d, 0xa4, 0x07, 0x26, 0x2a, 0xbd, 0x86, 0x51, 0xd4,
+	0x95, 0x11, 0xf6, 0x19, 0x5c, 0x49, 0x17, 0x48, 0xd1, 0x62, 0xfc, 0x02, 0x2b, 0x2a, 0xd8, 0x1a,
+	0xb7, 0xca, 0xba, 0xf3, 0x82, 0xd3, 0xd5, 0x4a, 0x2d, 0xb8, 0xb0, 0x30, 0xaa, 0x05, 0x17, 0x17,
+	0x39, 0x63, 0xc1, 0x2e, 0xa0, 0x7c, 0x95, 0x11, 0xc5, 0xfe, 0x2b, 0x2d, 0x7a, 0x1a, 0xe6, 0x30,
+	0x96, 0x8c, 0x92, 0x5d, 0x98, 0x4e, 0x94, 0xda, 0x50, 0xec, 0xc9, 0x7c, 0x01, 0xd3, 0xb8, 0x51,
+	0xd8, 0x97, 0x91, 0xf7, 0x05, 0x34, 0xb3, 0x79, 0x88, 0x0e, 0xba, 0x92, 0xea, 0x9d, 0x0e, 0xba,
+	0xd2, 0x4a, 0x5c, 0x24, 0xfe, 0x25, 0x80, 0xae, 0x44, 0xe9, 0x90, 0xc8, 0x95, 0xc2, 0x74, 0x48,
+	0xe4, 0x0b, 0x57, 0x91, 0xb0, 0xc7, 0xc2, 0xda, 0x6c, 0x65, 0x49, 0x5b, 0x5b, 0x52, 0xc8, 0xd2,
+	0xd6, 0x96, 0x15, 0xa5, 0x92, 0x5b, 0x24, 0x57, 0xaa, 0xd1, 0x5b, 0xa4, 0xac, 0x40, 0xa5, 0xb7,
+	0x48, 0x69, 0x9d, 0x27, 0xf6, 0xc7, 0x8f, 0x60, 0x62, 0x33, 0x74, 0x4f, 0xd0, 0x6c, 0x3c, 0x44,
+	0x57, 0x79, 0x8c, 0xb9, 0x34, 0x31, 0x33, 0x74, 0x03, 0x6a, 0x51, 0x5d, 0x00, 0xcd, 0x47, 0x9c,
+	0x99, 0xa2, 0x8d, 0xd1, 0xca, 0x77, 0xe4, 0x37, 0xa9, 0x2e, 0x2f, 0xe8, 0x15, 0xc9, 0x15, 0x4a,
+	0xf4, 0x8a, 0x14, 0x54, 0x23, 0x22, 0x61, 0x87, 0x70, 0x39, 0x55, 0x25, 0x40, 0x37, 0xe3, 0x29,
+	0x14, 0x14, 0x2b, 0x8c, 0xc5, 0x92, 0xde, 0xcc, 0x32, 0x3c, 0x07, 0xd0, 0xe8, 0xbd, 0x36, 0x31,
+	0x57, 0x61, 0xd0, 0x26, 0x16, 0x80, 0xfd, 0x89, 0x5d, 0x99, 0x07, 0xe0, 0xf5, 0xae, 0x2c, 0x2d,
+	0x08, 0xe8, 0x5d, 0x59, 0x8e, 0xdf, 0xc7, 0x16, 0x0b, 0x25, 0x59, 0xc8, 0x3c, 0xa9, 0xa4, 0x04,
+	0xc2, 0x4f, 0x2a, 0x29, 0x43, 0xdc, 0x63, 0x25, 0x34, 0x5f, 0x4e, 0x57, 0x50, 0x37, 0xba, 0x5f,
+	0xb6, 0x21, 0xd3, 0xc8, 0xbb, 0xf1, 0xee, 0xf7, 0xf2, 0x65, 0xbc, 0x77, 0x00, 0x8d, 0x24, 0xd4,
+	0x8d, 0x6e, 0xa4, 0x05, 0xa4, 0x30, 0x41, 0xe3, 0x66, 0x71, 0x67, 0x7a, 0x1a, 0x8f, 0x2b, 0xe8,
+	0x57, 0x60, 0x94, 0xa3, 0x7d, 0xe8, 0xbd, 0x61, 0x36, 0xa6, 0x15, 0xbe, 0xff, 0x36, 0xac, 0xe9,
+	0x19, 0x3d, 0xa8, 0xa0, 0x6d, 0xa8, 0xc7, 0x08, 0x34, 0x6a, 0x95, 0xe1, 0xe7, 0xc6, 0x42, 0x41,
+	0x4f, 0xc6, 0x3b, 0x9f, 0x40, 0x23, 0x89, 0x28, 0x6b, 0xef, 0x14, 0x80, 0xd9, 0xda, 0x3b, 0x85,
+	0x20, 0x74, 0xf2, 0x7c, 0xd7, 0x98, 0x64, 0xe2, 0x7c, 0xcf, 0x01, 0x9f, 0x89, 0xf3, 0x3d, 0x0f,
+	0x62, 0xc6, 0x41, 0xd3, 0x16, 0x7f, 0x44, 0xa4, 0x81, 0x44, 0x94, 0xfc, 0x25, 0xa1, 0x10, 0xb9,
+	0xd4, 0x47, 0x5a, 0x29, 0x0a, 0x99, 0x58, 0xcf, 0x2f, 0x61, 0x26, 0x87, 0x0c, 0x6a, 0x1d, 0x65,
+	0x50, 0xa4, 0xd6, 0x51, 0x0a, 0x2b, 0xc6, 0xb3, 0x58, 0x85, 0xaa, 0xfa, 0x8f, 0x09, 0x5d, 0x8f,
+	0x47, 0xa5, 0x7e, 0x92, 0x32, 0xe6, 0x73, 0xf4, 0x8c, 0x67, 0xf7, 0x61, 0x3a, 0x01, 0x1b, 0xa2,
+	0xe4, 0x85, 0x93, 0x81, 0x03, 0xb5, 0x67, 0x0b, 0x70, 0xc6, 0xc4, 0xbc, 0x7f, 0xcd, 0xd3, 0x8a,
+	0x21, 0x20, 0x1e, 0xfa, 0x60, 0x58, 0x7c, 0x66, 0x95, 0x3e, 0x7c, 0x3b, 0xe6, 0xcc, 0xac, 0x7e,
+	0x0e, 0x97, 0x53, 0x80, 0x94, 0x3e, 0x81, 0x8b, 0x50, 0x43, 0x7d, 0x02, 0x17, 0xa2, 0x58, 0x89,
+	0xb9, 0x9d, 0xc0, 0x5c, 0x11, 0x80, 0x80, 0xee, 0xea, 0x5d, 0x51, 0x0a, 0x85, 0x18, 0xf7, 0x86,
+	0x33, 0xe5, 0x94, 0xb5, 0x61, 0x26, 0x87, 0xc6, 0xe8, 0x00, 0x2a, 0x83, 0x89, 0x74, 0x00, 0x95,
+	0x42, 0x39, 0x09, 0x1d, 0x18, 0x50, 0xbe, 0xf4, 0x82, 0x12, 0xaf, 0xdb, 0x92, 0x0a, 0x90, 0x3e,
+	0xa2, 0x87, 0x54, 0x6e, 0xf4, 0xe1, 0xd2, 0x86, 0x99, 0x5c, 0xb5, 0x45, 0x4f, 0xa5, 0xac, 0xbc,
+	0xa3, 0xa7, 0x52, 0x5a, 0xaa, 0x49, 0x4c, 0xe5, 0x15, 0x5c, 0xcd, 0xc0, 0x06, 0xe8, 0x56, 0xea,
+	0x09, 0x92, 0x43, 0x39, 0x8c, 0xa5, 0xd2, 0xfe, 0x4c, 0x3c, 0x11, 0xb8, 0x5e, 0x0c, 0x0e, 0xa0,
+	0x77, 0x12, 0xa1, 0x53, 0x8e, 0x4b, 0x18, 0xf7, 0xbf, 0x8f, 0x2d, 0xb3, 0xb5, 0x0f, 0xe1, 0x72,
+	0x2a, 0xaf, 0xd5, 0x01, 0x5c, 0x84, 0x36, 0xe8, 0x00, 0x2e, 0xce, 0xf4, 0xa3, 0x69, 0xf8, 0x19,
+	0x28, 0x20, 0xca, 0x96, 0xd1, 0xbd, 0xc2, 0xf1, 0x19, 0x3c, 0xc0, 0x78, 0xe7, 0x7b, 0xb8, 0xf2,
+	0x8f, 0xe8, 0x6c, 0x96, 0x9c, 0xcc, 0xdc, 0x0a, 0x93, 0xf2, 0x64, 0xe6, 0x56, 0x92, 0x60, 0xa7,
+	0xc4, 0xa7, 0xd3, 0xdd, 0xa4, 0xf8, 0xc2, 0x14, 0x3c, 0x29, 0xbe, 0x24, 0x53, 0x8e, 0xc4, 0x1f,
+	0xc1, 0x6c, 0x41, 0xb2, 0x8a, 0x12, 0x71, 0x5f, 0x96, 0x4d, 0x1b, 0x77, 0x87, 0xf2, 0xa4, 0xf5,
+	0xac, 0x3e, 0x7e, 0xc5, 0xb9, 0x7d, 0xa7, 0xbd, 0xec, 0x92, 0xde, 0x23, 0xf9, 0xf9, 0x21, 0xa1,
+	0xc7, 0x8f, 0xa4, 0x8c, 0x47, 0xe2, 0xb7, 0xe8, 0x47, 0xc7, 0x44, 0xb5, 0xfb, 0xed, 0xf6, 0x94,
+	0x20, 0x3d, 0xfd, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x04, 0x75, 0x81, 0x0d, 0x5b, 0x2d, 0x00,
+	0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -4036,6 +4143,7 @@ type RepositoryServiceClient interface {
 	FetchSourceBranch(ctx context.Context, in *FetchSourceBranchRequest, opts ...grpc.CallOption) (*FetchSourceBranchResponse, error)
 	Fsck(ctx context.Context, in *FsckRequest, opts ...grpc.CallOption) (*FsckResponse, error)
 	WriteRef(ctx context.Context, in *WriteRefRequest, opts ...grpc.CallOption) (*WriteRefResponse, error)
+	WriteRefTx(ctx context.Context, in *WriteRefTxRequest, opts ...grpc.CallOption) (*WriteRefTxResponse, error)
 	FindMergeBase(ctx context.Context, in *FindMergeBaseRequest, opts ...grpc.CallOption) (*FindMergeBaseResponse, error)
 	CreateFork(ctx context.Context, in *CreateForkRequest, opts ...grpc.CallOption) (*CreateForkResponse, error)
 	IsRebaseInProgress(ctx context.Context, in *IsRebaseInProgressRequest, opts ...grpc.CallOption) (*IsRebaseInProgressResponse, error)
@@ -4213,6 +4321,15 @@ func (c *repositoryServiceClient) WriteRef(ctx context.Context, in *WriteRefRequ
 	return out, nil
 }
 
+func (c *repositoryServiceClient) WriteRefTx(ctx context.Context, in *WriteRefTxRequest, opts ...grpc.CallOption) (*WriteRefTxResponse, error) {
+	out := new(WriteRefTxResponse)
+	err := c.cc.Invoke(ctx, "/gitaly.RepositoryService/WriteRefTx", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *repositoryServiceClient) FindMergeBase(ctx context.Context, in *FindMergeBaseRequest, opts ...grpc.CallOption) (*FindMergeBaseResponse, error) {
 	out := new(FindMergeBaseResponse)
 	err := c.cc.Invoke(ctx, "/gitaly.RepositoryService/FindMergeBase", in, out, opts...)
@@ -4682,6 +4799,7 @@ type RepositoryServiceServer interface {
 	FetchSourceBranch(context.Context, *FetchSourceBranchRequest) (*FetchSourceBranchResponse, error)
 	Fsck(context.Context, *FsckRequest) (*FsckResponse, error)
 	WriteRef(context.Context, *WriteRefRequest) (*WriteRefResponse, error)
+	WriteRefTx(context.Context, *WriteRefTxRequest) (*WriteRefTxResponse, error)
 	FindMergeBase(context.Context, *FindMergeBaseRequest) (*FindMergeBaseResponse, error)
 	CreateFork(context.Context, *CreateForkRequest) (*CreateForkResponse, error)
 	IsRebaseInProgress(context.Context, *IsRebaseInProgressRequest) (*IsRebaseInProgressResponse, error)
@@ -4754,6 +4872,9 @@ func (*UnimplementedRepositoryServiceServer) Fsck(ctx context.Context, req *Fsck
 func (*UnimplementedRepositoryServiceServer) WriteRef(ctx context.Context, req *WriteRefRequest) (*WriteRefResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method WriteRef not implemented")
 }
+func (*UnimplementedRepositoryServiceServer) WriteRefTx(ctx context.Context, req *WriteRefTxRequest) (*WriteRefTxResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method WriteRefTx not implemented")
+}
 func (*UnimplementedRepositoryServiceServer) FindMergeBase(ctx context.Context, req *FindMergeBaseRequest) (*FindMergeBaseResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method FindMergeBase not implemented")
 }
@@ -5077,6 +5198,24 @@ func _RepositoryService_WriteRef_Handler(srv interface{}, ctx context.Context, d
 	return interceptor(ctx, in, info, handler)
 }
 
+func _RepositoryService_WriteRefTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(WriteRefTxRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RepositoryServiceServer).WriteRefTx(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.RepositoryService/WriteRefTx",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RepositoryServiceServer).WriteRefTx(ctx, req.(*WriteRefTxRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _RepositoryService_FindMergeBase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(FindMergeBaseRequest)
 	if err := dec(in); err != nil {
@@ -5652,6 +5791,10 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
 			MethodName: "WriteRef",
 			Handler:    _RepositoryService_WriteRef_Handler,
 		},
+		{
+			MethodName: "WriteRefTx",
+			Handler:    _RepositoryService_WriteRefTx_Handler,
+		},
 		{
 			MethodName: "FindMergeBase",
 			Handler:    _RepositoryService_FindMergeBase_Handler,
diff --git a/proto/go/gitalypb/shared.pb.go b/proto/go/gitalypb/shared.pb.go
index 1504b811668e60cbbfc10dd1d794f56f3cf2c675..e053478f01ed0479dae636ed070ab273cee928a3 100644
--- a/proto/go/gitalypb/shared.pb.go
+++ b/proto/go/gitalypb/shared.pb.go
@@ -140,6 +140,34 @@ func (OperationMsg_Scope) EnumDescriptor() ([]byte, []int) {
 	return fileDescriptor_d8a4e87e678c5ced, []int{0, 1}
 }
 
+type Transaction_TransactionStep int32
+
+const (
+	Transaction_PRECOMMIT Transaction_TransactionStep = 0
+	Transaction_COMMIT    Transaction_TransactionStep = 1
+	Transaction_ROLLBACK  Transaction_TransactionStep = 2
+)
+
+var Transaction_TransactionStep_name = map[int32]string{
+	0: "PRECOMMIT",
+	1: "COMMIT",
+	2: "ROLLBACK",
+}
+
+var Transaction_TransactionStep_value = map[string]int32{
+	"PRECOMMIT": 0,
+	"COMMIT":    1,
+	"ROLLBACK":  2,
+}
+
+func (x Transaction_TransactionStep) String() string {
+	return proto.EnumName(Transaction_TransactionStep_name, int32(x))
+}
+
+func (Transaction_TransactionStep) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_d8a4e87e678c5ced, []int{1, 0}
+}
+
 type OperationMsg struct {
 	Op OperationMsg_Operation `protobuf:"varint,1,opt,name=op,proto3,enum=gitaly.OperationMsg_Operation" json:"op,omitempty"`
 	// Scope level indicates what level an RPC interacts with a server:
@@ -191,6 +219,45 @@ func (m *OperationMsg) GetScopeLevel() OperationMsg_Scope {
 	return OperationMsg_REPOSITORY
 }
 
+type Transaction struct {
+	Step                 Transaction_TransactionStep `protobuf:"varint,1,opt,name=step,proto3,enum=gitaly.Transaction_TransactionStep" json:"step,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
+	XXX_unrecognized     []byte                      `json:"-"`
+	XXX_sizecache        int32                       `json:"-"`
+}
+
+func (m *Transaction) Reset()         { *m = Transaction{} }
+func (m *Transaction) String() string { return proto.CompactTextString(m) }
+func (*Transaction) ProtoMessage()    {}
+func (*Transaction) Descriptor() ([]byte, []int) {
+	return fileDescriptor_d8a4e87e678c5ced, []int{1}
+}
+
+func (m *Transaction) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Transaction.Unmarshal(m, b)
+}
+func (m *Transaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Transaction.Marshal(b, m, deterministic)
+}
+func (m *Transaction) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Transaction.Merge(m, src)
+}
+func (m *Transaction) XXX_Size() int {
+	return xxx_messageInfo_Transaction.Size(m)
+}
+func (m *Transaction) XXX_DiscardUnknown() {
+	xxx_messageInfo_Transaction.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Transaction proto.InternalMessageInfo
+
+func (m *Transaction) GetStep() Transaction_TransactionStep {
+	if m != nil {
+		return m.Step
+	}
+	return Transaction_PRECOMMIT
+}
+
 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"`
@@ -219,7 +286,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_d8a4e87e678c5ced, []int{1}
+	return fileDescriptor_d8a4e87e678c5ced, []int{2}
 }
 
 func (m *Repository) XXX_Unmarshal(b []byte) error {
@@ -304,7 +371,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_d8a4e87e678c5ced, []int{2}
+	return fileDescriptor_d8a4e87e678c5ced, []int{3}
 }
 
 func (m *GitCommit) XXX_Unmarshal(b []byte) error {
@@ -395,7 +462,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_d8a4e87e678c5ced, []int{3}
+	return fileDescriptor_d8a4e87e678c5ced, []int{4}
 }
 
 func (m *CommitAuthor) XXX_Unmarshal(b []byte) error {
@@ -455,7 +522,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_d8a4e87e678c5ced, []int{4}
+	return fileDescriptor_d8a4e87e678c5ced, []int{5}
 }
 
 func (m *ExitStatus) XXX_Unmarshal(b []byte) error {
@@ -496,7 +563,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_d8a4e87e678c5ced, []int{5}
+	return fileDescriptor_d8a4e87e678c5ced, []int{6}
 }
 
 func (m *Branch) XXX_Unmarshal(b []byte) error {
@@ -551,7 +618,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_d8a4e87e678c5ced, []int{6}
+	return fileDescriptor_d8a4e87e678c5ced, []int{7}
 }
 
 func (m *Tag) XXX_Unmarshal(b []byte) error {
@@ -635,7 +702,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_d8a4e87e678c5ced, []int{7}
+	return fileDescriptor_d8a4e87e678c5ced, []int{8}
 }
 
 func (m *User) XXX_Unmarshal(b []byte) error {
@@ -695,7 +762,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_d8a4e87e678c5ced, []int{8}
+	return fileDescriptor_d8a4e87e678c5ced, []int{9}
 }
 
 func (m *ObjectPool) XXX_Unmarshal(b []byte) error {
@@ -773,7 +840,9 @@ func init() {
 	proto.RegisterEnum("gitaly.SignatureType", SignatureType_name, SignatureType_value)
 	proto.RegisterEnum("gitaly.OperationMsg_Operation", OperationMsg_Operation_name, OperationMsg_Operation_value)
 	proto.RegisterEnum("gitaly.OperationMsg_Scope", OperationMsg_Scope_name, OperationMsg_Scope_value)
+	proto.RegisterEnum("gitaly.Transaction_TransactionStep", Transaction_TransactionStep_name, Transaction_TransactionStep_value)
 	proto.RegisterType((*OperationMsg)(nil), "gitaly.OperationMsg")
+	proto.RegisterType((*Transaction)(nil), "gitaly.Transaction")
 	proto.RegisterType((*Repository)(nil), "gitaly.Repository")
 	proto.RegisterType((*GitCommit)(nil), "gitaly.GitCommit")
 	proto.RegisterType((*CommitAuthor)(nil), "gitaly.CommitAuthor")
@@ -792,70 +861,74 @@ func init() {
 func init() { proto.RegisterFile("shared.proto", fileDescriptor_d8a4e87e678c5ced) }
 
 var fileDescriptor_d8a4e87e678c5ced = []byte{
-	// 1037 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0xdd, 0x6e, 0xe3, 0x44,
-	0x14, 0x6e, 0x1c, 0xe7, 0xef, 0x24, 0x2d, 0xde, 0xa1, 0x2b, 0x59, 0x45, 0xdd, 0x2d, 0x46, 0x42,
-	0xd5, 0xaa, 0xa4, 0x55, 0x57, 0x20, 0xb6, 0x20, 0xa1, 0xb4, 0x64, 0xab, 0x2e, 0x6d, 0x1c, 0x4d,
-	0x5c, 0xfe, 0x6e, 0xac, 0x49, 0x3c, 0x3b, 0x19, 0xe4, 0x64, 0x2c, 0x7b, 0x52, 0xd1, 0x5e, 0x22,
-	0xae, 0xb8, 0xe2, 0x25, 0xb8, 0xe5, 0x31, 0x10, 0xaf, 0xc1, 0xc2, 0x7b, 0x80, 0x66, 0xc6, 0x4e,
-	0xdd, 0x1f, 0x60, 0xf7, 0x6e, 0xce, 0xf1, 0x77, 0xbe, 0x39, 0xf3, 0xcd, 0x77, 0x26, 0x81, 0x4e,
-	0x36, 0x25, 0x29, 0x8d, 0xba, 0x49, 0x2a, 0xa4, 0x40, 0x75, 0xc6, 0x25, 0x89, 0x2f, 0x37, 0x1e,
-	0x33, 0x21, 0x58, 0x4c, 0x77, 0x75, 0x76, 0xbc, 0x78, 0xb9, 0x2b, 0xf9, 0x8c, 0x66, 0x92, 0xcc,
-	0x12, 0x03, 0xdc, 0xd8, 0xba, 0x0d, 0x88, 0x68, 0x36, 0x49, 0x79, 0x22, 0x45, 0x6a, 0x10, 0xde,
-	0xab, 0x0a, 0x74, 0xfc, 0x84, 0xa6, 0x44, 0x72, 0x31, 0x3f, 0xcb, 0x18, 0xea, 0x82, 0x25, 0x12,
-	0xb7, 0xb2, 0x55, 0xd9, 0x5e, 0xdb, 0x7f, 0xd4, 0x35, 0x1b, 0x75, 0xcb, 0x88, 0xeb, 0x00, 0x5b,
-	0x22, 0x41, 0x9f, 0x40, 0x3b, 0x9b, 0x88, 0x84, 0x86, 0x31, 0xbd, 0xa0, 0xb1, 0x6b, 0xe9, 0xc2,
-	0x8d, 0x7b, 0x0b, 0x47, 0x0a, 0x87, 0x41, 0xc3, 0x4f, 0x15, 0xda, 0x7b, 0x0a, 0xad, 0x25, 0x02,
-	0xb5, 0xa1, 0x71, 0x3e, 0xf8, 0x62, 0xe0, 0x7f, 0x35, 0x70, 0x56, 0x54, 0x70, 0x76, 0x1e, 0xf4,
-	0x02, 0x1f, 0x3b, 0x15, 0xd4, 0x81, 0x66, 0xef, 0xe8, 0xa8, 0x3f, 0x1a, 0xf9, 0xd8, 0xb1, 0xbc,
-	0x3d, 0xa8, 0x69, 0x26, 0xb4, 0x06, 0x80, 0xfb, 0x43, 0x7f, 0x74, 0x12, 0xf8, 0xf8, 0x1b, 0x67,
-	0x05, 0x01, 0xd4, 0x47, 0x7d, 0xfc, 0x65, 0x5f, 0x95, 0xb4, 0xa1, 0x31, 0x0a, 0x7c, 0xdc, 0x3b,
-	0xee, 0x3b, 0x96, 0xf7, 0xab, 0x05, 0x80, 0x69, 0x22, 0x32, 0x2e, 0x45, 0x7a, 0x89, 0xde, 0x85,
-	0x4e, 0x26, 0x45, 0x4a, 0x18, 0x0d, 0xe7, 0x64, 0x46, 0x75, 0xcf, 0x2d, 0xdc, 0xce, 0x73, 0x03,
-	0x32, 0xa3, 0xe8, 0x3d, 0x58, 0x4d, 0x69, 0x4c, 0x24, 0xbf, 0xa0, 0x61, 0x42, 0xe4, 0xd4, 0xad,
-	0x6a, 0x4c, 0xa7, 0x48, 0x0e, 0x89, 0x9c, 0xa2, 0x3d, 0x58, 0x67, 0x5c, 0x86, 0x62, 0xfc, 0x1d,
-	0x9d, 0xc8, 0x30, 0xe2, 0x29, 0x9d, 0x28, 0x7e, 0xd7, 0xd6, 0x58, 0xc4, 0xb8, 0xf4, 0xf5, 0xa7,
-	0xcf, 0x8b, 0x2f, 0xe8, 0x18, 0xb6, 0x54, 0x05, 0x89, 0x25, 0x4d, 0xe7, 0x44, 0xd2, 0xdb, 0xb5,
-	0x9c, 0x66, 0x6e, 0x6d, 0xab, 0xba, 0xdd, 0xc2, 0x9b, 0x8c, 0xcb, 0x5e, 0x01, 0xbb, 0x49, 0xc3,
-	0x69, 0xa6, 0xfa, 0x63, 0x71, 0x98, 0x2e, 0xcf, 0xe4, 0xd6, 0x4d, 0x7f, 0x2c, 0x2e, 0x9d, 0xf3,
-	0x7d, 0x78, 0x8b, 0xc5, 0x61, 0x92, 0x0a, 0xbd, 0x87, 0x3e, 0x46, 0x53, 0xc3, 0x56, 0x59, 0x3c,
-	0x34, 0x59, 0x75, 0x8e, 0x17, 0x76, 0xb3, 0xe2, 0x58, 0x2f, 0xec, 0x66, 0xc3, 0x69, 0x62, 0x5b,
-	0xc1, 0xbc, 0x5f, 0x2c, 0x68, 0x1d, 0x73, 0x79, 0x24, 0x66, 0x33, 0x2e, 0xd1, 0x1a, 0x58, 0x3c,
-	0xd2, 0x96, 0x68, 0x61, 0x8b, 0x47, 0xc8, 0x85, 0x46, 0xb6, 0xd0, 0x2d, 0x69, 0xe9, 0x3a, 0xb8,
-	0x08, 0x11, 0x02, 0x7b, 0x2c, 0xa2, 0x4b, 0xad, 0x56, 0x07, 0xeb, 0x35, 0xda, 0x81, 0x3a, 0x59,
-	0xc8, 0xa9, 0x48, 0xb5, 0x2e, 0xed, 0xfd, 0xf5, 0xc2, 0x1b, 0x86, 0xbd, 0xa7, 0xbf, 0xe1, 0x1c,
-	0x83, 0xf6, 0xa1, 0x35, 0xd1, 0x79, 0x49, 0x53, 0xb7, 0xf6, 0x1f, 0x05, 0xd7, 0x30, 0xb4, 0x09,
-	0x90, 0x90, 0x94, 0xce, 0x65, 0xc8, 0xa3, 0xcc, 0xad, 0x6b, 0xfd, 0x5a, 0x26, 0x73, 0x12, 0x65,
-	0xe8, 0x1d, 0x68, 0xa9, 0x46, 0xc2, 0x8c, 0x5f, 0x51, 0xb7, 0xb1, 0x55, 0xd9, 0xae, 0xe2, 0xa6,
-	0x4a, 0x8c, 0xf8, 0x15, 0x45, 0x9f, 0xc2, 0x5a, 0xc6, 0xd9, 0x9c, 0xc8, 0x45, 0x4a, 0x43, 0x79,
-	0x99, 0x50, 0x2d, 0xd1, 0xda, 0xfe, 0xc3, 0x62, 0xd3, 0x51, 0xf1, 0x35, 0xb8, 0x4c, 0x28, 0x5e,
-	0xcd, 0xca, 0xa1, 0xf7, 0x63, 0x05, 0x3a, 0xe5, 0xae, 0x94, 0x00, 0xda, 0x52, 0x15, 0x23, 0x80,
-	0x5a, 0xa3, 0x75, 0xa8, 0xd1, 0x19, 0xe1, 0x71, 0x2e, 0x96, 0x09, 0x50, 0x17, 0xec, 0x88, 0x48,
-	0xaa, 0xa5, 0x6a, 0xab, 0x81, 0xd1, 0x93, 0xda, 0x2d, 0x26, 0xb5, 0x1b, 0x14, 0xa3, 0x8c, 0x35,
-	0x0e, 0x6d, 0x40, 0x53, 0x4d, 0xf7, 0x95, 0x98, 0x53, 0x2d, 0x64, 0x07, 0x2f, 0x63, 0xcf, 0x03,
-	0xe8, 0x7f, 0xcf, 0xe5, 0x48, 0x12, 0xb9, 0xc8, 0xd4, 0x7e, 0x17, 0x24, 0x5e, 0x98, 0x26, 0x6a,
-	0xd8, 0x04, 0x5e, 0x00, 0xf5, 0xc3, 0x94, 0xcc, 0x27, 0xd3, 0x7b, 0x7b, 0xfc, 0x08, 0x56, 0x25,
-	0x49, 0x19, 0x95, 0xa1, 0x91, 0x55, 0xf7, 0xda, 0xde, 0x7f, 0x50, 0xa8, 0xb0, 0x34, 0x03, 0xee,
-	0x18, 0x9c, 0x89, 0xbc, 0x9f, 0x2c, 0xa8, 0x06, 0x84, 0xdd, 0xcb, 0x69, 0x6c, 0x63, 0x2d, 0x6d,
-	0x73, 0x67, 0x8f, 0xea, 0x6b, 0xed, 0xa1, 0xec, 0x36, 0xa3, 0x59, 0x46, 0x58, 0x71, 0xf0, 0x22,
-	0x54, 0x83, 0x9c, 0x2f, 0xcd, 0xe5, 0xd6, 0xf4, 0xe5, 0xb6, 0xf3, 0x9c, 0xbe, 0xdf, 0x1d, 0xa8,
-	0x4b, 0xc2, 0x18, 0x4d, 0xf5, 0x84, 0xfc, 0xab, 0xfb, 0x0c, 0xe6, 0x1e, 0x37, 0x34, 0xde, 0xc0,
-	0x0d, 0x2f, 0xc1, 0x3e, 0xcf, 0x68, 0x8a, 0xde, 0x86, 0x1a, 0x8b, 0xc3, 0xe5, 0xc8, 0xd8, 0x2c,
-	0x3e, 0x89, 0x96, 0x0a, 0x59, 0xf7, 0x39, 0xa3, 0x5a, 0x76, 0xc6, 0x63, 0x68, 0xb3, 0x38, 0x5c,
-	0x64, 0x6a, 0xf6, 0x67, 0x34, 0x7f, 0x4d, 0x80, 0xc5, 0xe7, 0x79, 0xc6, 0x7b, 0x0e, 0x60, 0x5e,
-	0x84, 0xa1, 0x10, 0x31, 0xfa, 0x18, 0xa0, 0xf4, 0x0e, 0x54, 0xf4, 0x29, 0x51, 0xd1, 0xef, 0xf5,
-	0x6b, 0x70, 0x68, 0xff, 0xfc, 0xdb, 0x4e, 0x05, 0x97, 0xb0, 0x4f, 0x0e, 0x0b, 0x1e, 0xd5, 0xfd,
-	0xcd, 0xe7, 0x17, 0xa0, 0x7e, 0xe4, 0x9f, 0x9d, 0x9d, 0x04, 0x4e, 0x05, 0x35, 0xc1, 0x3e, 0x3c,
-	0xf5, 0x0f, 0x1d, 0x4b, 0xad, 0x02, 0xdc, 0xef, 0x3b, 0x55, 0xd4, 0x80, 0x6a, 0xd0, 0x3b, 0x76,
-	0xec, 0x27, 0x3b, 0xb0, 0x7a, 0x43, 0x13, 0x85, 0x19, 0xf8, 0x83, 0xbe, 0xb3, 0xa2, 0x30, 0xc3,
-	0xe3, 0xa1, 0x21, 0xf8, 0xfa, 0xc3, 0xbd, 0x67, 0x8e, 0x75, 0xe0, 0x43, 0x43, 0x24, 0x5a, 0x58,
-	0xf4, 0xe8, 0x8e, 0xe3, 0xcf, 0xa8, 0x9c, 0x8a, 0xc8, 0x4f, 0xd4, 0x8f, 0x41, 0xe6, 0xfe, 0xfd,
-	0xc3, 0xad, 0xe9, 0x2f, 0xff, 0x94, 0xe0, 0xba, 0x48, 0xd4, 0x6e, 0x07, 0xcf, 0xa0, 0x91, 0x3f,
-	0xdb, 0x68, 0xf3, 0x0e, 0xe1, 0x73, 0x4e, 0xe3, 0x25, 0xdf, 0x1f, 0xbf, 0x2b, 0xbe, 0x26, 0x2e,
-	0xf0, 0x07, 0x9f, 0x95, 0x75, 0xfb, 0xbf, 0xea, 0x57, 0x79, 0x75, 0xa9, 0xe4, 0xe0, 0x14, 0x1e,
-	0xe4, 0x7e, 0x7e, 0x7d, 0x9e, 0x3f, 0x73, 0x1e, 0xc7, 0x54, 0x5e, 0x5f, 0xcf, 0x41, 0x00, 0x0f,
-	0x49, 0x14, 0x71, 0x05, 0x23, 0xf1, 0x1b, 0x30, 0xfe, 0x95, 0x33, 0xae, 0x5f, 0x57, 0x97, 0x2e,
-	0x7d, 0xef, 0x5b, 0x25, 0x5f, 0x4c, 0xc6, 0xdd, 0x89, 0x98, 0xed, 0x9a, 0xe5, 0x07, 0x22, 0x65,
-	0xbb, 0x46, 0x54, 0xf3, 0xc7, 0x60, 0x97, 0x89, 0x3c, 0x4e, 0xc6, 0xe3, 0xba, 0x4e, 0x3d, 0xfd,
-	0x27, 0x00, 0x00, 0xff, 0xff, 0xf3, 0x84, 0x06, 0x14, 0x72, 0x08, 0x00, 0x00,
+	// 1093 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x5d, 0x6f, 0xdb, 0x36,
+	0x17, 0xae, 0x65, 0xf9, 0xeb, 0xd8, 0x4e, 0x55, 0xbe, 0x29, 0x60, 0xe4, 0x45, 0xdb, 0x4c, 0x05,
+	0x86, 0xa2, 0xc8, 0x9c, 0x20, 0xc5, 0x3e, 0xea, 0x0d, 0x18, 0xec, 0xcc, 0x0d, 0xd2, 0x26, 0x96,
+	0x41, 0x2b, 0xfb, 0xba, 0x11, 0x68, 0x8b, 0xa5, 0x39, 0xc8, 0xa6, 0x20, 0xd1, 0xc5, 0x92, 0xcb,
+	0x62, 0x57, 0xbb, 0xda, 0x9f, 0xd8, 0xed, 0x7e, 0xc6, 0xb0, 0xbf, 0xb1, 0x6e, 0xff, 0x63, 0x03,
+	0x49, 0xc9, 0x51, 0x3e, 0xb6, 0xb5, 0x77, 0x3c, 0x87, 0xcf, 0x79, 0xce, 0xe1, 0xc3, 0xc3, 0x23,
+	0x41, 0x2b, 0x9d, 0x93, 0x84, 0x86, 0xdd, 0x38, 0x11, 0x52, 0xa0, 0x2a, 0xe3, 0x92, 0x44, 0x67,
+	0x5b, 0x0f, 0x98, 0x10, 0x2c, 0xa2, 0xbb, 0xda, 0x3b, 0x5d, 0xbd, 0xdc, 0x95, 0x7c, 0x41, 0x53,
+	0x49, 0x16, 0xb1, 0x01, 0x6e, 0x6d, 0x5f, 0x05, 0x84, 0x34, 0x9d, 0x25, 0x3c, 0x96, 0x22, 0x31,
+	0x08, 0xf7, 0x4d, 0x09, 0x5a, 0x5e, 0x4c, 0x13, 0x22, 0xb9, 0x58, 0x9e, 0xa4, 0x0c, 0x75, 0xc1,
+	0x12, 0x71, 0xa7, 0xb4, 0x5d, 0x7a, 0xb4, 0xb1, 0x7f, 0xbf, 0x6b, 0x12, 0x75, 0x8b, 0x88, 0x0b,
+	0x03, 0x5b, 0x22, 0x46, 0x9f, 0x42, 0x33, 0x9d, 0x89, 0x98, 0x06, 0x11, 0x7d, 0x45, 0xa3, 0x8e,
+	0xa5, 0x03, 0xb7, 0x6e, 0x0c, 0x9c, 0x28, 0x1c, 0x06, 0x0d, 0x3f, 0x56, 0x68, 0xf7, 0x09, 0x34,
+	0xd6, 0x08, 0xd4, 0x84, 0xda, 0xe9, 0xe8, 0xc5, 0xc8, 0xfb, 0x6a, 0xe4, 0xdc, 0x52, 0xc6, 0xc9,
+	0xa9, 0xdf, 0xf7, 0x3d, 0xec, 0x94, 0x50, 0x0b, 0xea, 0xfd, 0x83, 0x83, 0xe1, 0x64, 0xe2, 0x61,
+	0xc7, 0x72, 0xf7, 0xa0, 0xa2, 0x99, 0xd0, 0x06, 0x00, 0x1e, 0x8e, 0xbd, 0xc9, 0x91, 0xef, 0xe1,
+	0x6f, 0x9c, 0x5b, 0x08, 0xa0, 0x3a, 0x19, 0xe2, 0x2f, 0x87, 0x2a, 0xa4, 0x09, 0xb5, 0x89, 0xef,
+	0xe1, 0xfe, 0xe1, 0xd0, 0xb1, 0xdc, 0xd7, 0x25, 0x68, 0xfa, 0x09, 0x59, 0xa6, 0x64, 0xa6, 0x33,
+	0x7d, 0x0c, 0x76, 0x2a, 0x69, 0x7e, 0xca, 0x87, 0x79, 0xb1, 0x05, 0x48, 0x71, 0x3d, 0x91, 0x34,
+	0xc6, 0x3a, 0xc0, 0xed, 0xc1, 0xed, 0x2b, 0x1b, 0xa8, 0x0d, 0x8d, 0x31, 0x1e, 0x1e, 0x78, 0x27,
+	0x27, 0x47, 0xbe, 0xa9, 0x21, 0x5b, 0xeb, 0xb2, 0xb1, 0x77, 0x7c, 0x3c, 0xe8, 0x1f, 0xbc, 0x70,
+	0x2c, 0xf7, 0x17, 0x0b, 0x00, 0xd3, 0x58, 0xa4, 0x5c, 0x8a, 0xe4, 0x0c, 0xbd, 0x07, 0xad, 0x54,
+	0x8a, 0x84, 0x30, 0x1a, 0x2c, 0xc9, 0x82, 0x6a, 0xe1, 0x1a, 0xb8, 0x99, 0xf9, 0x46, 0x64, 0x41,
+	0xd1, 0x43, 0x68, 0x27, 0x34, 0x22, 0x92, 0xbf, 0xa2, 0x41, 0x4c, 0xe4, 0xbc, 0x53, 0xd6, 0x98,
+	0x56, 0xee, 0x1c, 0x13, 0x39, 0x47, 0x7b, 0xb0, 0xc9, 0xb8, 0x0c, 0xc4, 0xf4, 0x3b, 0x3a, 0x93,
+	0x41, 0xc8, 0x13, 0x3a, 0x53, 0xfc, 0x1d, 0x5b, 0x63, 0x11, 0xe3, 0xd2, 0xd3, 0x5b, 0x5f, 0xe4,
+	0x3b, 0xe8, 0x10, 0xb6, 0x55, 0x04, 0x89, 0x24, 0x4d, 0x96, 0x44, 0xd2, 0xab, 0xb1, 0x9c, 0xa6,
+	0x9d, 0xca, 0x76, 0xf9, 0x51, 0x03, 0xdf, 0x63, 0x5c, 0xf6, 0x73, 0xd8, 0x65, 0x1a, 0x4e, 0x53,
+	0x55, 0x1f, 0x8b, 0x82, 0x64, 0x7d, 0xa6, 0x4e, 0xd5, 0xd4, 0xc7, 0xa2, 0xc2, 0x39, 0xdf, 0x87,
+	0xdb, 0x2c, 0x0a, 0xe2, 0x44, 0xe8, 0x1c, 0xfa, 0x18, 0x75, 0x0d, 0x6b, 0xb3, 0x68, 0x6c, 0xbc,
+	0xea, 0x1c, 0xcf, 0xed, 0x7a, 0xc9, 0xb1, 0x9e, 0xdb, 0xf5, 0x9a, 0x53, 0xc7, 0xb6, 0x82, 0xb9,
+	0x3f, 0x5b, 0xd0, 0x38, 0xe4, 0xf2, 0x40, 0x2c, 0x16, 0x5c, 0xa2, 0x0d, 0xb0, 0x78, 0xa8, 0x6f,
+	0xac, 0x81, 0x2d, 0x1e, 0xa2, 0x0e, 0xd4, 0xd2, 0x95, 0x2e, 0x49, 0x4b, 0xd7, 0xc2, 0xb9, 0x89,
+	0x10, 0xd8, 0x53, 0x11, 0x9e, 0x69, 0xb5, 0x5a, 0x58, 0xaf, 0xd1, 0x0e, 0x54, 0xc9, 0x4a, 0xce,
+	0x45, 0xa2, 0x75, 0x69, 0xee, 0x6f, 0xe6, 0x77, 0x6e, 0xd8, 0xfb, 0x7a, 0x0f, 0x67, 0x18, 0xb4,
+	0x0f, 0x8d, 0x99, 0xf6, 0x4b, 0x9a, 0x74, 0x2a, 0xff, 0x12, 0x70, 0x01, 0x43, 0xf7, 0x00, 0x62,
+	0x92, 0xd0, 0xa5, 0x0c, 0x78, 0x98, 0x76, 0xaa, 0x5a, 0xbf, 0x86, 0xf1, 0x1c, 0x85, 0x29, 0xfa,
+	0x3f, 0x34, 0x54, 0x21, 0x41, 0xca, 0xcf, 0x69, 0xa7, 0xb6, 0x5d, 0x7a, 0x54, 0xc6, 0x75, 0xe5,
+	0x98, 0xf0, 0x73, 0x8a, 0x3e, 0x83, 0x8d, 0x94, 0xb3, 0x25, 0x91, 0xab, 0x84, 0x06, 0xf2, 0x2c,
+	0xa6, 0x5a, 0xa2, 0x8d, 0xfd, 0xbb, 0x79, 0xd2, 0x49, 0xbe, 0xeb, 0x9f, 0xc5, 0x14, 0xb7, 0xd3,
+	0xa2, 0xe9, 0xfe, 0x50, 0x82, 0x56, 0xb1, 0x2a, 0x25, 0x80, 0x6e, 0xa9, 0x92, 0x11, 0x40, 0xad,
+	0xd1, 0x26, 0x54, 0xe8, 0x82, 0xf0, 0x28, 0x13, 0xcb, 0x18, 0xa8, 0x0b, 0x76, 0x48, 0x24, 0xd5,
+	0x52, 0x35, 0xd5, 0xab, 0xd5, 0xe3, 0xa2, 0x9b, 0x8f, 0x8b, 0xae, 0x9f, 0xcf, 0x13, 0xac, 0x71,
+	0x68, 0x0b, 0xea, 0x6a, 0xc4, 0x9c, 0x8b, 0x25, 0xd5, 0x42, 0xb6, 0xf0, 0xda, 0x76, 0x5d, 0x80,
+	0xe1, 0xf7, 0x5c, 0x4e, 0x24, 0x91, 0xab, 0x54, 0xe5, 0x7b, 0x45, 0xa2, 0x95, 0x29, 0xa2, 0x82,
+	0x8d, 0xe1, 0xfa, 0x50, 0x1d, 0x24, 0x64, 0x39, 0x9b, 0xdf, 0x58, 0xe3, 0x47, 0xd0, 0x96, 0x24,
+	0x61, 0x54, 0x06, 0x46, 0x56, 0x5d, 0x6b, 0x73, 0xff, 0x4e, 0xae, 0xc2, 0xba, 0x19, 0x70, 0xcb,
+	0xe0, 0x8c, 0xe5, 0xfe, 0x68, 0x41, 0xd9, 0x27, 0xec, 0x46, 0x4e, 0xd3, 0x36, 0xd6, 0xba, 0x6d,
+	0xae, 0xe5, 0x28, 0xbf, 0x55, 0x0e, 0xd5, 0x6e, 0x0b, 0x9a, 0xa6, 0x84, 0xe5, 0x07, 0xcf, 0x4d,
+	0xf5, 0x90, 0xb3, 0xa5, 0xb9, 0xdc, 0x8a, 0xbe, 0xdc, 0x66, 0xe6, 0xd3, 0xf7, 0xbb, 0x03, 0x55,
+	0x49, 0x18, 0xa3, 0x89, 0x7e, 0x21, 0xff, 0xd8, 0x7d, 0x06, 0x73, 0x43, 0x37, 0xd4, 0xde, 0xa1,
+	0x1b, 0x5e, 0x82, 0x7d, 0x9a, 0xd2, 0x04, 0xfd, 0x0f, 0x2a, 0x2c, 0x0a, 0xd6, 0x4f, 0xc6, 0x66,
+	0xd1, 0x51, 0xb8, 0x56, 0xc8, 0xba, 0xa9, 0x33, 0xca, 0xc5, 0xce, 0x78, 0x00, 0x4d, 0x16, 0x05,
+	0xab, 0x54, 0xbd, 0xfd, 0x05, 0xcd, 0xa6, 0x09, 0xb0, 0xe8, 0x34, 0xf3, 0xb8, 0xcf, 0x00, 0xcc,
+	0x44, 0x18, 0x0b, 0x11, 0xa1, 0x4f, 0x00, 0x0a, 0x73, 0xa0, 0xa4, 0x4f, 0x89, 0xf2, 0x7a, 0x2f,
+	0xa6, 0xc1, 0xc0, 0xfe, 0xe9, 0xd7, 0x9d, 0x12, 0x2e, 0x60, 0x1f, 0x0f, 0x72, 0x1e, 0x55, 0xfd,
+	0xe5, 0x6f, 0x40, 0x71, 0x96, 0xd6, 0xc1, 0x1e, 0x1c, 0x7b, 0x03, 0xc7, 0x52, 0x2b, 0x1f, 0x0f,
+	0x87, 0x4e, 0x19, 0xd5, 0xa0, 0xec, 0xf7, 0x0f, 0x1d, 0xfb, 0xf1, 0x0e, 0xb4, 0x2f, 0x69, 0xa2,
+	0x30, 0x23, 0x6f, 0x34, 0x74, 0x6e, 0x29, 0xcc, 0xf8, 0x70, 0x6c, 0x08, 0xbe, 0xfe, 0x70, 0xef,
+	0xa9, 0x63, 0xf5, 0x3c, 0xa8, 0x89, 0x58, 0x0b, 0x8b, 0xee, 0x5f, 0xeb, 0xf8, 0x13, 0x2a, 0xe7,
+	0x22, 0xf4, 0x62, 0x35, 0xdf, 0xd3, 0xce, 0x5f, 0xaf, 0xaf, 0xbc, 0xfe, 0xe2, 0xf7, 0x0c, 0x57,
+	0x45, 0xac, 0xb2, 0xf5, 0x9e, 0x42, 0x2d, 0x1b, 0xdb, 0xe8, 0xde, 0x35, 0xc2, 0x67, 0x9c, 0x46,
+	0x6b, 0xbe, 0xdf, 0x7f, 0x53, 0x7c, 0x75, 0x9c, 0xe3, 0x7b, 0x9f, 0x17, 0x75, 0xfb, 0xaf, 0xe8,
+	0x37, 0x59, 0x74, 0x21, 0xa4, 0x77, 0x0c, 0x77, 0xb2, 0x7e, 0x7e, 0x7b, 0x9e, 0x3f, 0x32, 0x1e,
+	0xc7, 0x44, 0x5e, 0x5c, 0x4f, 0xcf, 0x87, 0xbb, 0x24, 0x0c, 0xb9, 0x82, 0x91, 0xe8, 0x1d, 0x18,
+	0xff, 0xcc, 0x18, 0x37, 0x2f, 0xa2, 0x0b, 0x97, 0xbe, 0xf7, 0xad, 0x92, 0x2f, 0x22, 0xd3, 0xee,
+	0x4c, 0x2c, 0x76, 0xcd, 0xf2, 0x03, 0x91, 0xb0, 0x5d, 0x23, 0xaa, 0xf9, 0x3b, 0xd9, 0x65, 0x22,
+	0xb3, 0xe3, 0xe9, 0xb4, 0xaa, 0x5d, 0x4f, 0xfe, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xee, 0xd3, 0x49,
+	0x70, 0xf7, 0x08, 0x00, 0x00,
 }
diff --git a/proto/repository-service.proto b/proto/repository-service.proto
index b502c4f5c17069f600a7f109acdde294270f407d..ca3cd91184fdede6a41f9750de5b45abcb5c0597 100644
--- a/proto/repository-service.proto
+++ b/proto/repository-service.proto
@@ -72,6 +72,11 @@ service RepositoryService {
       op: MUTATOR
     };
   }
+  rpc WriteRefTx(WriteRefTxRequest) returns (WriteRefTxResponse) {
+      option (op_type) = {
+      op: MUTATOR
+    };
+  }
   rpc FindMergeBase(FindMergeBaseRequest) returns (FindMergeBaseResponse) {
     option (op_type) = {
       op: ACCESSOR
@@ -339,11 +344,21 @@ message WriteRefRequest {
 }
 
 message WriteRefResponse {
-  // This used to contain an error message. Since we're shelling out
-  // all exceptions are wrapped in GRPC errors.
-  reserved 1;
+    // This used to contain an error message. Since we're shelling out
+    // all exceptions are wrapped in GRPC errors.
+    reserved 1;
 }
 
+message WriteRefTxRequest {
+    Repository repository = 1 [(target_repository)=true];
+    bytes ref = 2;
+    bytes revision = 3;
+    bytes old_revision = 4;
+    bool force = 5;
+}
+
+message WriteRefTxResponse {}
+
 message FindMergeBaseRequest {
   Repository repository = 1 [(target_repository)=true];
   // We use a repeated field because rugged supports finding a base
diff --git a/proto/shared.proto b/proto/shared.proto
index bb5886fd8ea42f1910030815f04cd3a4cf4cae5d..cd84477624b3d7f38d37421b143ee40f1e23e1e6 100644
--- a/proto/shared.proto
+++ b/proto/shared.proto
@@ -29,6 +29,16 @@ message OperationMsg {
   Scope scope_level = 2;
 }
 
+message Transaction {
+    enum TransactionStep {
+        PRECOMMIT = 0;
+        COMMIT = 1;
+        ROLLBACK = 2;
+    }
+
+    TransactionStep step = 1;
+}
+
 enum ObjectType {
   UNKNOWN = 0;
   COMMIT = 1;
diff --git a/ruby/proto/gitaly/repository-service_pb.rb b/ruby/proto/gitaly/repository-service_pb.rb
index e3ed2339eb051813dc4f4bbfea5e9cd07d19d137..c1a5d00244f8f18927f3a98ede41aa02be29dd56 100644
--- a/ruby/proto/gitaly/repository-service_pb.rb
+++ b/ruby/proto/gitaly/repository-service_pb.rb
@@ -109,6 +109,15 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
   end
   add_message "gitaly.WriteRefResponse" do
   end
+  add_message "gitaly.WriteRefTxRequest" do
+    optional :repository, :message, 1, "gitaly.Repository"
+    optional :ref, :bytes, 2
+    optional :revision, :bytes, 3
+    optional :old_revision, :bytes, 4
+    optional :force, :bool, 5
+  end
+  add_message "gitaly.WriteRefTxResponse" do
+  end
   add_message "gitaly.FindMergeBaseRequest" do
     optional :repository, :message, 1, "gitaly.Repository"
     repeated :revisions, :bytes, 2
@@ -347,6 +356,8 @@ module Gitaly
   FsckResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.FsckResponse").msgclass
   WriteRefRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.WriteRefRequest").msgclass
   WriteRefResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.WriteRefResponse").msgclass
+  WriteRefTxRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.WriteRefTxRequest").msgclass
+  WriteRefTxResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.WriteRefTxResponse").msgclass
   FindMergeBaseRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.FindMergeBaseRequest").msgclass
   FindMergeBaseResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.FindMergeBaseResponse").msgclass
   CreateForkRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.CreateForkRequest").msgclass
diff --git a/ruby/proto/gitaly/repository-service_services_pb.rb b/ruby/proto/gitaly/repository-service_services_pb.rb
index 61928048fb82b25aa2b68ca6e08a3675271292cf..d9f2d9385b12bf4c30ba7ba64804867b7ed96e4c 100644
--- a/ruby/proto/gitaly/repository-service_services_pb.rb
+++ b/ruby/proto/gitaly/repository-service_services_pb.rb
@@ -27,6 +27,7 @@ module Gitaly
       rpc :FetchSourceBranch, FetchSourceBranchRequest, FetchSourceBranchResponse
       rpc :Fsck, FsckRequest, FsckResponse
       rpc :WriteRef, WriteRefRequest, WriteRefResponse
+      rpc :WriteRefTx, WriteRefTxRequest, WriteRefTxResponse
       rpc :FindMergeBase, FindMergeBaseRequest, FindMergeBaseResponse
       rpc :CreateFork, CreateForkRequest, CreateForkResponse
       rpc :IsRebaseInProgress, IsRebaseInProgressRequest, IsRebaseInProgressResponse
diff --git a/ruby/proto/gitaly/shared_pb.rb b/ruby/proto/gitaly/shared_pb.rb
index 1b0a316629d1422c75151b109ad7f846b1fdb4a4..b70b4d9003f91206f94383a4fd2d9850f5530df9 100644
--- a/ruby/proto/gitaly/shared_pb.rb
+++ b/ruby/proto/gitaly/shared_pb.rb
@@ -19,6 +19,14 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     value :SERVER, 1
     value :STORAGE, 2
   end
+  add_message "gitaly.Transaction" do
+    optional :step, :enum, 1, "gitaly.Transaction.TransactionStep"
+  end
+  add_enum "gitaly.Transaction.TransactionStep" do
+    value :PRECOMMIT, 0
+    value :COMMIT, 1
+    value :ROLLBACK, 2
+  end
   add_message "gitaly.Repository" do
     optional :storage_name, :string, 2
     optional :relative_path, :string, 3
@@ -86,6 +94,8 @@ module Gitaly
   OperationMsg = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.OperationMsg").msgclass
   OperationMsg::Operation = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.OperationMsg.Operation").enummodule
   OperationMsg::Scope = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.OperationMsg.Scope").enummodule
+  Transaction = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.Transaction").msgclass
+  Transaction::TransactionStep = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.Transaction.TransactionStep").enummodule
   Repository = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.Repository").msgclass
   GitCommit = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.GitCommit").msgclass
   CommitAuthor = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.CommitAuthor").msgclass