graveler.go

// Code generated by MockGen. DO NOT EDIT.
// Source: graveler.go

// Package mock is a generated GoMock package.
package mock

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	graveler "github.com/treeverse/lakefs/pkg/graveler"
)

// MockKeyValueStore is a mock of KeyValueStore interface.
type MockKeyValueStore struct {
	ctrl     *gomock.Controller
	recorder *MockKeyValueStoreMockRecorder
}

// MockKeyValueStoreMockRecorder is the mock recorder for MockKeyValueStore.
type MockKeyValueStoreMockRecorder struct {
	mock *MockKeyValueStore
}

// NewMockKeyValueStore creates a new mock instance.
func NewMockKeyValueStore(ctrl *gomock.Controller) *MockKeyValueStore {
	mock := &MockKeyValueStore{ctrl: ctrl}
	mock.recorder = &MockKeyValueStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockKeyValueStore) EXPECT() *MockKeyValueStoreMockRecorder {
	return m.recorder
}

// Delete mocks base method.
func (m *MockKeyValueStore) Delete(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID, key graveler.Key) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, repository, branchID, key)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockKeyValueStoreMockRecorder) Delete(ctx, repository, branchID, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockKeyValueStore)(nil).Delete), ctx, repository, branchID, key)
}

// DeleteBatch mocks base method.
func (m *MockKeyValueStore) DeleteBatch(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID, keys []graveler.Key) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBatch", ctx, repository, branchID, keys)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteBatch indicates an expected call of DeleteBatch.
func (mr *MockKeyValueStoreMockRecorder) DeleteBatch(ctx, repository, branchID, keys interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBatch", reflect.TypeOf((*MockKeyValueStore)(nil).DeleteBatch), ctx, repository, branchID, keys)
}

// Get mocks base method.
func (m *MockKeyValueStore) Get(ctx context.Context, repository *graveler.RepositoryRecord, ref graveler.Ref, key graveler.Key, opts ...graveler.GetOptionsFunc) (*graveler.Value, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, repository, ref, key}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Get", varargs...)
	ret0, _ := ret[0].(*graveler.Value)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockKeyValueStoreMockRecorder) Get(ctx, repository, ref, key interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, repository, ref, key}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockKeyValueStore)(nil).Get), varargs...)
}

// GetByCommitID mocks base method.
func (m *MockKeyValueStore) GetByCommitID(ctx context.Context, repository *graveler.RepositoryRecord, commitID graveler.CommitID, key graveler.Key) (*graveler.Value, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByCommitID", ctx, repository, commitID, key)
	ret0, _ := ret[0].(*graveler.Value)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByCommitID indicates an expected call of GetByCommitID.
func (mr *MockKeyValueStoreMockRecorder) GetByCommitID(ctx, repository, commitID, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByCommitID", reflect.TypeOf((*MockKeyValueStore)(nil).GetByCommitID), ctx, repository, commitID, key)
}

// List mocks base method.
func (m *MockKeyValueStore) List(ctx context.Context, repository *graveler.RepositoryRecord, ref graveler.Ref, batchSize int) (graveler.ValueIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, repository, ref, batchSize)
	ret0, _ := ret[0].(graveler.ValueIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockKeyValueStoreMockRecorder) List(ctx, repository, ref, batchSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockKeyValueStore)(nil).List), ctx, repository, ref, batchSize)
}

// ListStaging mocks base method.
func (m *MockKeyValueStore) ListStaging(ctx context.Context, branch *graveler.Branch, batchSize int) (graveler.ValueIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStaging", ctx, branch, batchSize)
	ret0, _ := ret[0].(graveler.ValueIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListStaging indicates an expected call of ListStaging.
func (mr *MockKeyValueStoreMockRecorder) ListStaging(ctx, branch, batchSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStaging", reflect.TypeOf((*MockKeyValueStore)(nil).ListStaging), ctx, branch, batchSize)
}

// Set mocks base method.
func (m *MockKeyValueStore) Set(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID, key graveler.Key, value graveler.Value, opts ...graveler.SetOptionsFunc) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, repository, branchID, key, value}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Set", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Set indicates an expected call of Set.
func (mr *MockKeyValueStoreMockRecorder) Set(ctx, repository, branchID, key, value interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, repository, branchID, key, value}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockKeyValueStore)(nil).Set), varargs...)
}

// MockVersionController is a mock of VersionController interface.
type MockVersionController struct {
	ctrl     *gomock.Controller
	recorder *MockVersionControllerMockRecorder
}

// MockVersionControllerMockRecorder is the mock recorder for MockVersionController.
type MockVersionControllerMockRecorder struct {
	mock *MockVersionController
}

// NewMockVersionController creates a new mock instance.
func NewMockVersionController(ctrl *gomock.Controller) *MockVersionController {
	mock := &MockVersionController{ctrl: ctrl}
	mock.recorder = &MockVersionControllerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVersionController) EXPECT() *MockVersionControllerMockRecorder {
	return m.recorder
}

// AddCommit mocks base method.
func (m *MockVersionController) AddCommit(ctx context.Context, repository *graveler.RepositoryRecord, commit graveler.Commit) (graveler.CommitID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddCommit", ctx, repository, commit)
	ret0, _ := ret[0].(graveler.CommitID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddCommit indicates an expected call of AddCommit.
func (mr *MockVersionControllerMockRecorder) AddCommit(ctx, repository, commit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCommit", reflect.TypeOf((*MockVersionController)(nil).AddCommit), ctx, repository, commit)
}

// Commit mocks base method.
func (m *MockVersionController) Commit(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID, commitParams graveler.CommitParams) (graveler.CommitID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Commit", ctx, repository, branchID, commitParams)
	ret0, _ := ret[0].(graveler.CommitID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Commit indicates an expected call of Commit.
func (mr *MockVersionControllerMockRecorder) Commit(ctx, repository, branchID, commitParams interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockVersionController)(nil).Commit), ctx, repository, branchID, commitParams)
}

// Compare mocks base method.
func (m *MockVersionController) Compare(ctx context.Context, repository *graveler.RepositoryRecord, left, right graveler.Ref) (graveler.DiffIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Compare", ctx, repository, left, right)
	ret0, _ := ret[0].(graveler.DiffIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Compare indicates an expected call of Compare.
func (mr *MockVersionControllerMockRecorder) Compare(ctx, repository, left, right interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Compare", reflect.TypeOf((*MockVersionController)(nil).Compare), ctx, repository, left, right)
}

// CreateBareRepository mocks base method.
func (m *MockVersionController) CreateBareRepository(ctx context.Context, repositoryID graveler.RepositoryID, storageNamespace graveler.StorageNamespace, defaultBranchID graveler.BranchID) (*graveler.RepositoryRecord, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBareRepository", ctx, repositoryID, storageNamespace, defaultBranchID)
	ret0, _ := ret[0].(*graveler.RepositoryRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateBareRepository indicates an expected call of CreateBareRepository.
func (mr *MockVersionControllerMockRecorder) CreateBareRepository(ctx, repositoryID, storageNamespace, defaultBranchID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBareRepository", reflect.TypeOf((*MockVersionController)(nil).CreateBareRepository), ctx, repositoryID, storageNamespace, defaultBranchID)
}

// CreateBranch mocks base method.
func (m *MockVersionController) CreateBranch(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID, ref graveler.Ref) (*graveler.Branch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBranch", ctx, repository, branchID, ref)
	ret0, _ := ret[0].(*graveler.Branch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateBranch indicates an expected call of CreateBranch.
func (mr *MockVersionControllerMockRecorder) CreateBranch(ctx, repository, branchID, ref interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBranch", reflect.TypeOf((*MockVersionController)(nil).CreateBranch), ctx, repository, branchID, ref)
}

// CreateBranchProtectionRule mocks base method.
func (m *MockVersionController) CreateBranchProtectionRule(ctx context.Context, repository *graveler.RepositoryRecord, pattern string, blockedActions []graveler.BranchProtectionBlockedAction) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBranchProtectionRule", ctx, repository, pattern, blockedActions)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateBranchProtectionRule indicates an expected call of CreateBranchProtectionRule.
func (mr *MockVersionControllerMockRecorder) CreateBranchProtectionRule(ctx, repository, pattern, blockedActions interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBranchProtectionRule", reflect.TypeOf((*MockVersionController)(nil).CreateBranchProtectionRule), ctx, repository, pattern, blockedActions)
}

// CreateRepository mocks base method.
func (m *MockVersionController) CreateRepository(ctx context.Context, repositoryID graveler.RepositoryID, storageNamespace graveler.StorageNamespace, branchID graveler.BranchID) (*graveler.RepositoryRecord, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRepository", ctx, repositoryID, storageNamespace, branchID)
	ret0, _ := ret[0].(*graveler.RepositoryRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRepository indicates an expected call of CreateRepository.
func (mr *MockVersionControllerMockRecorder) CreateRepository(ctx, repositoryID, storageNamespace, branchID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRepository", reflect.TypeOf((*MockVersionController)(nil).CreateRepository), ctx, repositoryID, storageNamespace, branchID)
}

// CreateTag mocks base method.
func (m *MockVersionController) CreateTag(ctx context.Context, repository *graveler.RepositoryRecord, tagID graveler.TagID, commitID graveler.CommitID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTag", ctx, repository, tagID, commitID)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateTag indicates an expected call of CreateTag.
func (mr *MockVersionControllerMockRecorder) CreateTag(ctx, repository, tagID, commitID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTag", reflect.TypeOf((*MockVersionController)(nil).CreateTag), ctx, repository, tagID, commitID)
}

// DeleteBranch mocks base method.
func (m *MockVersionController) DeleteBranch(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBranch", ctx, repository, branchID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteBranch indicates an expected call of DeleteBranch.
func (mr *MockVersionControllerMockRecorder) DeleteBranch(ctx, repository, branchID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBranch", reflect.TypeOf((*MockVersionController)(nil).DeleteBranch), ctx, repository, branchID)
}

// DeleteBranchProtectionRule mocks base method.
func (m *MockVersionController) DeleteBranchProtectionRule(ctx context.Context, repository *graveler.RepositoryRecord, pattern string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBranchProtectionRule", ctx, repository, pattern)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteBranchProtectionRule indicates an expected call of DeleteBranchProtectionRule.
func (mr *MockVersionControllerMockRecorder) DeleteBranchProtectionRule(ctx, repository, pattern interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBranchProtectionRule", reflect.TypeOf((*MockVersionController)(nil).DeleteBranchProtectionRule), ctx, repository, pattern)
}

// DeleteExpiredLinkAddresses mocks base method.
func (m *MockVersionController) DeleteExpiredLinkAddresses(ctx context.Context, repository *graveler.RepositoryRecord) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteExpiredLinkAddresses", ctx, repository)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteExpiredLinkAddresses indicates an expected call of DeleteExpiredLinkAddresses.
func (mr *MockVersionControllerMockRecorder) DeleteExpiredLinkAddresses(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExpiredLinkAddresses", reflect.TypeOf((*MockVersionController)(nil).DeleteExpiredLinkAddresses), ctx, repository)
}

// DeleteRepository mocks base method.
func (m *MockVersionController) DeleteRepository(ctx context.Context, repositoryID graveler.RepositoryID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRepository", ctx, repositoryID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteRepository indicates an expected call of DeleteRepository.
func (mr *MockVersionControllerMockRecorder) DeleteRepository(ctx, repositoryID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRepository", reflect.TypeOf((*MockVersionController)(nil).DeleteRepository), ctx, repositoryID)
}

// DeleteTag mocks base method.
func (m *MockVersionController) DeleteTag(ctx context.Context, repository *graveler.RepositoryRecord, tagID graveler.TagID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTag", ctx, repository, tagID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTag indicates an expected call of DeleteTag.
func (mr *MockVersionControllerMockRecorder) DeleteTag(ctx, repository, tagID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTag", reflect.TypeOf((*MockVersionController)(nil).DeleteTag), ctx, repository, tagID)
}

// Dereference mocks base method.
func (m *MockVersionController) Dereference(ctx context.Context, repository *graveler.RepositoryRecord, ref graveler.Ref) (*graveler.ResolvedRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Dereference", ctx, repository, ref)
	ret0, _ := ret[0].(*graveler.ResolvedRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Dereference indicates an expected call of Dereference.
func (mr *MockVersionControllerMockRecorder) Dereference(ctx, repository, ref interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dereference", reflect.TypeOf((*MockVersionController)(nil).Dereference), ctx, repository, ref)
}

// Diff mocks base method.
func (m *MockVersionController) Diff(ctx context.Context, repository *graveler.RepositoryRecord, left, right graveler.Ref) (graveler.DiffIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Diff", ctx, repository, left, right)
	ret0, _ := ret[0].(graveler.DiffIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Diff indicates an expected call of Diff.
func (mr *MockVersionControllerMockRecorder) Diff(ctx, repository, left, right interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Diff", reflect.TypeOf((*MockVersionController)(nil).Diff), ctx, repository, left, right)
}

// DiffUncommitted mocks base method.
func (m *MockVersionController) DiffUncommitted(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID) (graveler.DiffIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DiffUncommitted", ctx, repository, branchID)
	ret0, _ := ret[0].(graveler.DiffIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DiffUncommitted indicates an expected call of DiffUncommitted.
func (mr *MockVersionControllerMockRecorder) DiffUncommitted(ctx, repository, branchID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiffUncommitted", reflect.TypeOf((*MockVersionController)(nil).DiffUncommitted), ctx, repository, branchID)
}

// FindMergeBase mocks base method.
func (m *MockVersionController) FindMergeBase(ctx context.Context, repository *graveler.RepositoryRecord, from, to graveler.Ref) (*graveler.CommitRecord, *graveler.CommitRecord, *graveler.Commit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindMergeBase", ctx, repository, from, to)
	ret0, _ := ret[0].(*graveler.CommitRecord)
	ret1, _ := ret[1].(*graveler.CommitRecord)
	ret2, _ := ret[2].(*graveler.Commit)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// FindMergeBase indicates an expected call of FindMergeBase.
func (mr *MockVersionControllerMockRecorder) FindMergeBase(ctx, repository, from, to interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindMergeBase", reflect.TypeOf((*MockVersionController)(nil).FindMergeBase), ctx, repository, from, to)
}

// GCGetUncommittedLocation mocks base method.
func (m *MockVersionController) GCGetUncommittedLocation(repository *graveler.RepositoryRecord, runID string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GCGetUncommittedLocation", repository, runID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GCGetUncommittedLocation indicates an expected call of GCGetUncommittedLocation.
func (mr *MockVersionControllerMockRecorder) GCGetUncommittedLocation(repository, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GCGetUncommittedLocation", reflect.TypeOf((*MockVersionController)(nil).GCGetUncommittedLocation), repository, runID)
}

// GCNewRunID mocks base method.
func (m *MockVersionController) GCNewRunID() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GCNewRunID")
	ret0, _ := ret[0].(string)
	return ret0
}

// GCNewRunID indicates an expected call of GCNewRunID.
func (mr *MockVersionControllerMockRecorder) GCNewRunID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GCNewRunID", reflect.TypeOf((*MockVersionController)(nil).GCNewRunID))
}

// GetBranch mocks base method.
func (m *MockVersionController) GetBranch(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID) (*graveler.Branch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBranch", ctx, repository, branchID)
	ret0, _ := ret[0].(*graveler.Branch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBranch indicates an expected call of GetBranch.
func (mr *MockVersionControllerMockRecorder) GetBranch(ctx, repository, branchID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBranch", reflect.TypeOf((*MockVersionController)(nil).GetBranch), ctx, repository, branchID)
}

// GetBranchProtectionRules mocks base method.
func (m *MockVersionController) GetBranchProtectionRules(ctx context.Context, repository *graveler.RepositoryRecord) (*graveler.BranchProtectionRules, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBranchProtectionRules", ctx, repository)
	ret0, _ := ret[0].(*graveler.BranchProtectionRules)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBranchProtectionRules indicates an expected call of GetBranchProtectionRules.
func (mr *MockVersionControllerMockRecorder) GetBranchProtectionRules(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBranchProtectionRules", reflect.TypeOf((*MockVersionController)(nil).GetBranchProtectionRules), ctx, repository)
}

// GetCommit mocks base method.
func (m *MockVersionController) GetCommit(ctx context.Context, repository *graveler.RepositoryRecord, commitID graveler.CommitID) (*graveler.Commit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommit", ctx, repository, commitID)
	ret0, _ := ret[0].(*graveler.Commit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCommit indicates an expected call of GetCommit.
func (mr *MockVersionControllerMockRecorder) GetCommit(ctx, repository, commitID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommit", reflect.TypeOf((*MockVersionController)(nil).GetCommit), ctx, repository, commitID)
}

// GetGarbageCollectionRules mocks base method.
func (m *MockVersionController) GetGarbageCollectionRules(ctx context.Context, repository *graveler.RepositoryRecord) (*graveler.GarbageCollectionRules, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGarbageCollectionRules", ctx, repository)
	ret0, _ := ret[0].(*graveler.GarbageCollectionRules)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGarbageCollectionRules indicates an expected call of GetGarbageCollectionRules.
func (mr *MockVersionControllerMockRecorder) GetGarbageCollectionRules(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGarbageCollectionRules", reflect.TypeOf((*MockVersionController)(nil).GetGarbageCollectionRules), ctx, repository)
}

// GetRepository mocks base method.
func (m *MockVersionController) GetRepository(ctx context.Context, repositoryID graveler.RepositoryID) (*graveler.RepositoryRecord, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRepository", ctx, repositoryID)
	ret0, _ := ret[0].(*graveler.RepositoryRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRepository indicates an expected call of GetRepository.
func (mr *MockVersionControllerMockRecorder) GetRepository(ctx, repositoryID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepository", reflect.TypeOf((*MockVersionController)(nil).GetRepository), ctx, repositoryID)
}

// GetStagingToken mocks base method.
func (m *MockVersionController) GetStagingToken(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID) (*graveler.StagingToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStagingToken", ctx, repository, branchID)
	ret0, _ := ret[0].(*graveler.StagingToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStagingToken indicates an expected call of GetStagingToken.
func (mr *MockVersionControllerMockRecorder) GetStagingToken(ctx, repository, branchID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStagingToken", reflect.TypeOf((*MockVersionController)(nil).GetStagingToken), ctx, repository, branchID)
}

// GetTag mocks base method.
func (m *MockVersionController) GetTag(ctx context.Context, repository *graveler.RepositoryRecord, tagID graveler.TagID) (*graveler.CommitID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTag", ctx, repository, tagID)
	ret0, _ := ret[0].(*graveler.CommitID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTag indicates an expected call of GetTag.
func (mr *MockVersionControllerMockRecorder) GetTag(ctx, repository, tagID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTag", reflect.TypeOf((*MockVersionController)(nil).GetTag), ctx, repository, tagID)
}

// IsLinkAddressExpired mocks base method.
func (m *MockVersionController) IsLinkAddressExpired(token *graveler.LinkAddressData) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsLinkAddressExpired", token)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsLinkAddressExpired indicates an expected call of IsLinkAddressExpired.
func (mr *MockVersionControllerMockRecorder) IsLinkAddressExpired(token interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsLinkAddressExpired", reflect.TypeOf((*MockVersionController)(nil).IsLinkAddressExpired), token)
}

// ListBranches mocks base method.
func (m *MockVersionController) ListBranches(ctx context.Context, repository *graveler.RepositoryRecord) (graveler.BranchIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBranches", ctx, repository)
	ret0, _ := ret[0].(graveler.BranchIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBranches indicates an expected call of ListBranches.
func (mr *MockVersionControllerMockRecorder) ListBranches(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBranches", reflect.TypeOf((*MockVersionController)(nil).ListBranches), ctx, repository)
}

// ListLinkAddresses mocks base method.
func (m *MockVersionController) ListLinkAddresses(ctx context.Context, repository *graveler.RepositoryRecord) (graveler.AddressTokenIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLinkAddresses", ctx, repository)
	ret0, _ := ret[0].(graveler.AddressTokenIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLinkAddresses indicates an expected call of ListLinkAddresses.
func (mr *MockVersionControllerMockRecorder) ListLinkAddresses(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLinkAddresses", reflect.TypeOf((*MockVersionController)(nil).ListLinkAddresses), ctx, repository)
}

// ListRepositories mocks base method.
func (m *MockVersionController) ListRepositories(ctx context.Context) (graveler.RepositoryIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRepositories", ctx)
	ret0, _ := ret[0].(graveler.RepositoryIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRepositories indicates an expected call of ListRepositories.
func (mr *MockVersionControllerMockRecorder) ListRepositories(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRepositories", reflect.TypeOf((*MockVersionController)(nil).ListRepositories), ctx)
}

// ListTags mocks base method.
func (m *MockVersionController) ListTags(ctx context.Context, repository *graveler.RepositoryRecord) (graveler.TagIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTags", ctx, repository)
	ret0, _ := ret[0].(graveler.TagIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTags indicates an expected call of ListTags.
func (mr *MockVersionControllerMockRecorder) ListTags(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTags", reflect.TypeOf((*MockVersionController)(nil).ListTags), ctx, repository)
}

// Log mocks base method.
func (m *MockVersionController) Log(ctx context.Context, repository *graveler.RepositoryRecord, commitID graveler.CommitID) (graveler.CommitIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Log", ctx, repository, commitID)
	ret0, _ := ret[0].(graveler.CommitIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Log indicates an expected call of Log.
func (mr *MockVersionControllerMockRecorder) Log(ctx, repository, commitID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Log", reflect.TypeOf((*MockVersionController)(nil).Log), ctx, repository, commitID)
}

// Merge mocks base method.
func (m *MockVersionController) Merge(ctx context.Context, repository *graveler.RepositoryRecord, destination graveler.BranchID, source graveler.Ref, commitParams graveler.CommitParams, strategy string) (graveler.CommitID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Merge", ctx, repository, destination, source, commitParams, strategy)
	ret0, _ := ret[0].(graveler.CommitID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Merge indicates an expected call of Merge.
func (mr *MockVersionControllerMockRecorder) Merge(ctx, repository, destination, source, commitParams, strategy interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Merge", reflect.TypeOf((*MockVersionController)(nil).Merge), ctx, repository, destination, source, commitParams, strategy)
}

// ParseRef mocks base method.
func (m *MockVersionController) ParseRef(ref graveler.Ref) (graveler.RawRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParseRef", ref)
	ret0, _ := ret[0].(graveler.RawRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ParseRef indicates an expected call of ParseRef.
func (mr *MockVersionControllerMockRecorder) ParseRef(ref interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ParseRef", reflect.TypeOf((*MockVersionController)(nil).ParseRef), ref)
}

// Reset mocks base method.
func (m *MockVersionController) Reset(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reset", ctx, repository, branchID)
	ret0, _ := ret[0].(error)
	return ret0
}

// Reset indicates an expected call of Reset.
func (mr *MockVersionControllerMockRecorder) Reset(ctx, repository, branchID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockVersionController)(nil).Reset), ctx, repository, branchID)
}

// ResetKey mocks base method.
func (m *MockVersionController) ResetKey(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID, key graveler.Key) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetKey", ctx, repository, branchID, key)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResetKey indicates an expected call of ResetKey.
func (mr *MockVersionControllerMockRecorder) ResetKey(ctx, repository, branchID, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetKey", reflect.TypeOf((*MockVersionController)(nil).ResetKey), ctx, repository, branchID, key)
}

// ResetPrefix mocks base method.
func (m *MockVersionController) ResetPrefix(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID, key graveler.Key) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetPrefix", ctx, repository, branchID, key)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResetPrefix indicates an expected call of ResetPrefix.
func (mr *MockVersionControllerMockRecorder) ResetPrefix(ctx, repository, branchID, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetPrefix", reflect.TypeOf((*MockVersionController)(nil).ResetPrefix), ctx, repository, branchID, key)
}

// ResolveRawRef mocks base method.
func (m *MockVersionController) ResolveRawRef(ctx context.Context, repository *graveler.RepositoryRecord, rawRef graveler.RawRef) (*graveler.ResolvedRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolveRawRef", ctx, repository, rawRef)
	ret0, _ := ret[0].(*graveler.ResolvedRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResolveRawRef indicates an expected call of ResolveRawRef.
func (mr *MockVersionControllerMockRecorder) ResolveRawRef(ctx, repository, rawRef interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveRawRef", reflect.TypeOf((*MockVersionController)(nil).ResolveRawRef), ctx, repository, rawRef)
}

// Revert mocks base method.
func (m *MockVersionController) Revert(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID, ref graveler.Ref, parentNumber int, commitParams graveler.CommitParams) (graveler.CommitID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Revert", ctx, repository, branchID, ref, parentNumber, commitParams)
	ret0, _ := ret[0].(graveler.CommitID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Revert indicates an expected call of Revert.
func (mr *MockVersionControllerMockRecorder) Revert(ctx, repository, branchID, ref, parentNumber, commitParams interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Revert", reflect.TypeOf((*MockVersionController)(nil).Revert), ctx, repository, branchID, ref, parentNumber, commitParams)
}

// SaveGarbageCollectionCommits mocks base method.
func (m *MockVersionController) SaveGarbageCollectionCommits(ctx context.Context, repository *graveler.RepositoryRecord, previousRunID string) (*graveler.GarbageCollectionRunMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveGarbageCollectionCommits", ctx, repository, previousRunID)
	ret0, _ := ret[0].(*graveler.GarbageCollectionRunMetadata)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SaveGarbageCollectionCommits indicates an expected call of SaveGarbageCollectionCommits.
func (mr *MockVersionControllerMockRecorder) SaveGarbageCollectionCommits(ctx, repository, previousRunID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveGarbageCollectionCommits", reflect.TypeOf((*MockVersionController)(nil).SaveGarbageCollectionCommits), ctx, repository, previousRunID)
}

// SetGarbageCollectionRules mocks base method.
func (m *MockVersionController) SetGarbageCollectionRules(ctx context.Context, repository *graveler.RepositoryRecord, rules *graveler.GarbageCollectionRules) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetGarbageCollectionRules", ctx, repository, rules)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetGarbageCollectionRules indicates an expected call of SetGarbageCollectionRules.
func (mr *MockVersionControllerMockRecorder) SetGarbageCollectionRules(ctx, repository, rules interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGarbageCollectionRules", reflect.TypeOf((*MockVersionController)(nil).SetGarbageCollectionRules), ctx, repository, rules)
}

// SetHooksHandler mocks base method.
func (m *MockVersionController) SetHooksHandler(handler graveler.HooksHandler) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetHooksHandler", handler)
}

// SetHooksHandler indicates an expected call of SetHooksHandler.
func (mr *MockVersionControllerMockRecorder) SetHooksHandler(handler interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHooksHandler", reflect.TypeOf((*MockVersionController)(nil).SetHooksHandler), handler)
}

// SetLinkAddress mocks base method.
func (m *MockVersionController) SetLinkAddress(ctx context.Context, repository *graveler.RepositoryRecord, token string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLinkAddress", ctx, repository, token)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLinkAddress indicates an expected call of SetLinkAddress.
func (mr *MockVersionControllerMockRecorder) SetLinkAddress(ctx, repository, token interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLinkAddress", reflect.TypeOf((*MockVersionController)(nil).SetLinkAddress), ctx, repository, token)
}

// UpdateBranch mocks base method.
func (m *MockVersionController) UpdateBranch(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID, ref graveler.Ref) (*graveler.Branch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBranch", ctx, repository, branchID, ref)
	ret0, _ := ret[0].(*graveler.Branch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateBranch indicates an expected call of UpdateBranch.
func (mr *MockVersionControllerMockRecorder) UpdateBranch(ctx, repository, branchID, ref interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBranch", reflect.TypeOf((*MockVersionController)(nil).UpdateBranch), ctx, repository, branchID, ref)
}

// VerifyLinkAddress mocks base method.
func (m *MockVersionController) VerifyLinkAddress(ctx context.Context, repository *graveler.RepositoryRecord, token string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyLinkAddress", ctx, repository, token)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyLinkAddress indicates an expected call of VerifyLinkAddress.
func (mr *MockVersionControllerMockRecorder) VerifyLinkAddress(ctx, repository, token interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyLinkAddress", reflect.TypeOf((*MockVersionController)(nil).VerifyLinkAddress), ctx, repository, token)
}

// WriteMetaRangeByIterator mocks base method.
func (m *MockVersionController) WriteMetaRangeByIterator(ctx context.Context, repository *graveler.RepositoryRecord, it graveler.ValueIterator) (*graveler.MetaRangeID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteMetaRangeByIterator", ctx, repository, it)
	ret0, _ := ret[0].(*graveler.MetaRangeID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteMetaRangeByIterator indicates an expected call of WriteMetaRangeByIterator.
func (mr *MockVersionControllerMockRecorder) WriteMetaRangeByIterator(ctx, repository, it interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteMetaRangeByIterator", reflect.TypeOf((*MockVersionController)(nil).WriteMetaRangeByIterator), ctx, repository, it)
}

// MockPlumbing is a mock of Plumbing interface.
type MockPlumbing struct {
	ctrl     *gomock.Controller
	recorder *MockPlumbingMockRecorder
}

// MockPlumbingMockRecorder is the mock recorder for MockPlumbing.
type MockPlumbingMockRecorder struct {
	mock *MockPlumbing
}

// NewMockPlumbing creates a new mock instance.
func NewMockPlumbing(ctrl *gomock.Controller) *MockPlumbing {
	mock := &MockPlumbing{ctrl: ctrl}
	mock.recorder = &MockPlumbingMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPlumbing) EXPECT() *MockPlumbingMockRecorder {
	return m.recorder
}

// GetMetaRange mocks base method.
func (m *MockPlumbing) GetMetaRange(ctx context.Context, repository *graveler.RepositoryRecord, metaRangeID graveler.MetaRangeID) (graveler.MetaRangeAddress, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetaRange", ctx, repository, metaRangeID)
	ret0, _ := ret[0].(graveler.MetaRangeAddress)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMetaRange indicates an expected call of GetMetaRange.
func (mr *MockPlumbingMockRecorder) GetMetaRange(ctx, repository, metaRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetaRange", reflect.TypeOf((*MockPlumbing)(nil).GetMetaRange), ctx, repository, metaRangeID)
}

// GetRange mocks base method.
func (m *MockPlumbing) GetRange(ctx context.Context, repository *graveler.RepositoryRecord, rangeID graveler.RangeID) (graveler.RangeAddress, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRange", ctx, repository, rangeID)
	ret0, _ := ret[0].(graveler.RangeAddress)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRange indicates an expected call of GetRange.
func (mr *MockPlumbingMockRecorder) GetRange(ctx, repository, rangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRange", reflect.TypeOf((*MockPlumbing)(nil).GetRange), ctx, repository, rangeID)
}

// WriteMetaRange mocks base method.
func (m *MockPlumbing) WriteMetaRange(ctx context.Context, repository *graveler.RepositoryRecord, ranges []*graveler.RangeInfo) (*graveler.MetaRangeInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteMetaRange", ctx, repository, ranges)
	ret0, _ := ret[0].(*graveler.MetaRangeInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteMetaRange indicates an expected call of WriteMetaRange.
func (mr *MockPlumbingMockRecorder) WriteMetaRange(ctx, repository, ranges interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteMetaRange", reflect.TypeOf((*MockPlumbing)(nil).WriteMetaRange), ctx, repository, ranges)
}

// WriteRange mocks base method.
func (m *MockPlumbing) WriteRange(ctx context.Context, repository *graveler.RepositoryRecord, it graveler.ValueIterator) (*graveler.RangeInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteRange", ctx, repository, it)
	ret0, _ := ret[0].(*graveler.RangeInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteRange indicates an expected call of WriteRange.
func (mr *MockPlumbingMockRecorder) WriteRange(ctx, repository, it interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteRange", reflect.TypeOf((*MockPlumbing)(nil).WriteRange), ctx, repository, it)
}

// MockDumper is a mock of Dumper interface.
type MockDumper struct {
	ctrl     *gomock.Controller
	recorder *MockDumperMockRecorder
}

// MockDumperMockRecorder is the mock recorder for MockDumper.
type MockDumperMockRecorder struct {
	mock *MockDumper
}

// NewMockDumper creates a new mock instance.
func NewMockDumper(ctrl *gomock.Controller) *MockDumper {
	mock := &MockDumper{ctrl: ctrl}
	mock.recorder = &MockDumperMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDumper) EXPECT() *MockDumperMockRecorder {
	return m.recorder
}

// DumpBranches mocks base method.
func (m *MockDumper) DumpBranches(ctx context.Context, repository *graveler.RepositoryRecord) (*graveler.MetaRangeID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DumpBranches", ctx, repository)
	ret0, _ := ret[0].(*graveler.MetaRangeID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DumpBranches indicates an expected call of DumpBranches.
func (mr *MockDumperMockRecorder) DumpBranches(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DumpBranches", reflect.TypeOf((*MockDumper)(nil).DumpBranches), ctx, repository)
}

// DumpCommits mocks base method.
func (m *MockDumper) DumpCommits(ctx context.Context, repository *graveler.RepositoryRecord) (*graveler.MetaRangeID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DumpCommits", ctx, repository)
	ret0, _ := ret[0].(*graveler.MetaRangeID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DumpCommits indicates an expected call of DumpCommits.
func (mr *MockDumperMockRecorder) DumpCommits(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DumpCommits", reflect.TypeOf((*MockDumper)(nil).DumpCommits), ctx, repository)
}

// DumpTags mocks base method.
func (m *MockDumper) DumpTags(ctx context.Context, repository *graveler.RepositoryRecord) (*graveler.MetaRangeID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DumpTags", ctx, repository)
	ret0, _ := ret[0].(*graveler.MetaRangeID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DumpTags indicates an expected call of DumpTags.
func (mr *MockDumperMockRecorder) DumpTags(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DumpTags", reflect.TypeOf((*MockDumper)(nil).DumpTags), ctx, repository)
}

// MockLoader is a mock of Loader interface.
type MockLoader struct {
	ctrl     *gomock.Controller
	recorder *MockLoaderMockRecorder
}

// MockLoaderMockRecorder is the mock recorder for MockLoader.
type MockLoaderMockRecorder struct {
	mock *MockLoader
}

// NewMockLoader creates a new mock instance.
func NewMockLoader(ctrl *gomock.Controller) *MockLoader {
	mock := &MockLoader{ctrl: ctrl}
	mock.recorder = &MockLoaderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockLoader) EXPECT() *MockLoaderMockRecorder {
	return m.recorder
}

// LoadBranches mocks base method.
func (m *MockLoader) LoadBranches(ctx context.Context, repository *graveler.RepositoryRecord, metaRangeID graveler.MetaRangeID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBranches", ctx, repository, metaRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadBranches indicates an expected call of LoadBranches.
func (mr *MockLoaderMockRecorder) LoadBranches(ctx, repository, metaRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBranches", reflect.TypeOf((*MockLoader)(nil).LoadBranches), ctx, repository, metaRangeID)
}

// LoadCommits mocks base method.
func (m *MockLoader) LoadCommits(ctx context.Context, repository *graveler.RepositoryRecord, metaRangeID graveler.MetaRangeID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadCommits", ctx, repository, metaRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadCommits indicates an expected call of LoadCommits.
func (mr *MockLoaderMockRecorder) LoadCommits(ctx, repository, metaRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadCommits", reflect.TypeOf((*MockLoader)(nil).LoadCommits), ctx, repository, metaRangeID)
}

// LoadTags mocks base method.
func (m *MockLoader) LoadTags(ctx context.Context, repository *graveler.RepositoryRecord, metaRangeID graveler.MetaRangeID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadTags", ctx, repository, metaRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadTags indicates an expected call of LoadTags.
func (mr *MockLoaderMockRecorder) LoadTags(ctx, repository, metaRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadTags", reflect.TypeOf((*MockLoader)(nil).LoadTags), ctx, repository, metaRangeID)
}

// MockRepositoryIterator is a mock of RepositoryIterator interface.
type MockRepositoryIterator struct {
	ctrl     *gomock.Controller
	recorder *MockRepositoryIteratorMockRecorder
}

// MockRepositoryIteratorMockRecorder is the mock recorder for MockRepositoryIterator.
type MockRepositoryIteratorMockRecorder struct {
	mock *MockRepositoryIterator
}

// NewMockRepositoryIterator creates a new mock instance.
func NewMockRepositoryIterator(ctrl *gomock.Controller) *MockRepositoryIterator {
	mock := &MockRepositoryIterator{ctrl: ctrl}
	mock.recorder = &MockRepositoryIteratorMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRepositoryIterator) EXPECT() *MockRepositoryIteratorMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockRepositoryIterator) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockRepositoryIteratorMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockRepositoryIterator)(nil).Close))
}

// Err mocks base method.
func (m *MockRepositoryIterator) Err() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Err")
	ret0, _ := ret[0].(error)
	return ret0
}

// Err indicates an expected call of Err.
func (mr *MockRepositoryIteratorMockRecorder) Err() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Err", reflect.TypeOf((*MockRepositoryIterator)(nil).Err))
}

// Next mocks base method.
func (m *MockRepositoryIterator) Next() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Next")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Next indicates an expected call of Next.
func (mr *MockRepositoryIteratorMockRecorder) Next() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockRepositoryIterator)(nil).Next))
}

// SeekGE mocks base method.
func (m *MockRepositoryIterator) SeekGE(id graveler.RepositoryID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SeekGE", id)
}

// SeekGE indicates an expected call of SeekGE.
func (mr *MockRepositoryIteratorMockRecorder) SeekGE(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SeekGE", reflect.TypeOf((*MockRepositoryIterator)(nil).SeekGE), id)
}

// Value mocks base method.
func (m *MockRepositoryIterator) Value() *graveler.RepositoryRecord {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Value")
	ret0, _ := ret[0].(*graveler.RepositoryRecord)
	return ret0
}

// Value indicates an expected call of Value.
func (mr *MockRepositoryIteratorMockRecorder) Value() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Value", reflect.TypeOf((*MockRepositoryIterator)(nil).Value))
}

// MockValueIterator is a mock of ValueIterator interface.
type MockValueIterator struct {
	ctrl     *gomock.Controller
	recorder *MockValueIteratorMockRecorder
}

// MockValueIteratorMockRecorder is the mock recorder for MockValueIterator.
type MockValueIteratorMockRecorder struct {
	mock *MockValueIterator
}

// NewMockValueIterator creates a new mock instance.
func NewMockValueIterator(ctrl *gomock.Controller) *MockValueIterator {
	mock := &MockValueIterator{ctrl: ctrl}
	mock.recorder = &MockValueIteratorMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockValueIterator) EXPECT() *MockValueIteratorMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockValueIterator) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockValueIteratorMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockValueIterator)(nil).Close))
}

// Err mocks base method.
func (m *MockValueIterator) Err() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Err")
	ret0, _ := ret[0].(error)
	return ret0
}

// Err indicates an expected call of Err.
func (mr *MockValueIteratorMockRecorder) Err() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Err", reflect.TypeOf((*MockValueIterator)(nil).Err))
}

// Next mocks base method.
func (m *MockValueIterator) Next() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Next")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Next indicates an expected call of Next.
func (mr *MockValueIteratorMockRecorder) Next() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockValueIterator)(nil).Next))
}

// SeekGE mocks base method.
func (m *MockValueIterator) SeekGE(id graveler.Key) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SeekGE", id)
}

// SeekGE indicates an expected call of SeekGE.
func (mr *MockValueIteratorMockRecorder) SeekGE(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SeekGE", reflect.TypeOf((*MockValueIterator)(nil).SeekGE), id)
}

// Value mocks base method.
func (m *MockValueIterator) Value() *graveler.ValueRecord {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Value")
	ret0, _ := ret[0].(*graveler.ValueRecord)
	return ret0
}

// Value indicates an expected call of Value.
func (mr *MockValueIteratorMockRecorder) Value() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Value", reflect.TypeOf((*MockValueIterator)(nil).Value))
}

// MockDiffIterator is a mock of DiffIterator interface.
type MockDiffIterator struct {
	ctrl     *gomock.Controller
	recorder *MockDiffIteratorMockRecorder
}

// MockDiffIteratorMockRecorder is the mock recorder for MockDiffIterator.
type MockDiffIteratorMockRecorder struct {
	mock *MockDiffIterator
}

// NewMockDiffIterator creates a new mock instance.
func NewMockDiffIterator(ctrl *gomock.Controller) *MockDiffIterator {
	mock := &MockDiffIterator{ctrl: ctrl}
	mock.recorder = &MockDiffIteratorMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDiffIterator) EXPECT() *MockDiffIteratorMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockDiffIterator) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockDiffIteratorMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockDiffIterator)(nil).Close))
}

// Err mocks base method.
func (m *MockDiffIterator) Err() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Err")
	ret0, _ := ret[0].(error)
	return ret0
}

// Err indicates an expected call of Err.
func (mr *MockDiffIteratorMockRecorder) Err() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Err", reflect.TypeOf((*MockDiffIterator)(nil).Err))
}

// Next mocks base method.
func (m *MockDiffIterator) Next() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Next")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Next indicates an expected call of Next.
func (mr *MockDiffIteratorMockRecorder) Next() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockDiffIterator)(nil).Next))
}

// SeekGE mocks base method.
func (m *MockDiffIterator) SeekGE(id graveler.Key) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SeekGE", id)
}

// SeekGE indicates an expected call of SeekGE.
func (mr *MockDiffIteratorMockRecorder) SeekGE(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SeekGE", reflect.TypeOf((*MockDiffIterator)(nil).SeekGE), id)
}

// Value mocks base method.
func (m *MockDiffIterator) Value() *graveler.Diff {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Value")
	ret0, _ := ret[0].(*graveler.Diff)
	return ret0
}

// Value indicates an expected call of Value.
func (mr *MockDiffIteratorMockRecorder) Value() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Value", reflect.TypeOf((*MockDiffIterator)(nil).Value))
}

// MockBranchIterator is a mock of BranchIterator interface.
type MockBranchIterator struct {
	ctrl     *gomock.Controller
	recorder *MockBranchIteratorMockRecorder
}

// MockBranchIteratorMockRecorder is the mock recorder for MockBranchIterator.
type MockBranchIteratorMockRecorder struct {
	mock *MockBranchIterator
}

// NewMockBranchIterator creates a new mock instance.
func NewMockBranchIterator(ctrl *gomock.Controller) *MockBranchIterator {
	mock := &MockBranchIterator{ctrl: ctrl}
	mock.recorder = &MockBranchIteratorMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBranchIterator) EXPECT() *MockBranchIteratorMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockBranchIterator) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockBranchIteratorMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockBranchIterator)(nil).Close))
}

// Err mocks base method.
func (m *MockBranchIterator) Err() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Err")
	ret0, _ := ret[0].(error)
	return ret0
}

// Err indicates an expected call of Err.
func (mr *MockBranchIteratorMockRecorder) Err() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Err", reflect.TypeOf((*MockBranchIterator)(nil).Err))
}

// Next mocks base method.
func (m *MockBranchIterator) Next() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Next")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Next indicates an expected call of Next.
func (mr *MockBranchIteratorMockRecorder) Next() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockBranchIterator)(nil).Next))
}

// SeekGE mocks base method.
func (m *MockBranchIterator) SeekGE(id graveler.BranchID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SeekGE", id)
}

// SeekGE indicates an expected call of SeekGE.
func (mr *MockBranchIteratorMockRecorder) SeekGE(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SeekGE", reflect.TypeOf((*MockBranchIterator)(nil).SeekGE), id)
}

// Value mocks base method.
func (m *MockBranchIterator) Value() *graveler.BranchRecord {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Value")
	ret0, _ := ret[0].(*graveler.BranchRecord)
	return ret0
}

// Value indicates an expected call of Value.
func (mr *MockBranchIteratorMockRecorder) Value() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Value", reflect.TypeOf((*MockBranchIterator)(nil).Value))
}

// MockTagIterator is a mock of TagIterator interface.
type MockTagIterator struct {
	ctrl     *gomock.Controller
	recorder *MockTagIteratorMockRecorder
}

// MockTagIteratorMockRecorder is the mock recorder for MockTagIterator.
type MockTagIteratorMockRecorder struct {
	mock *MockTagIterator
}

// NewMockTagIterator creates a new mock instance.
func NewMockTagIterator(ctrl *gomock.Controller) *MockTagIterator {
	mock := &MockTagIterator{ctrl: ctrl}
	mock.recorder = &MockTagIteratorMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTagIterator) EXPECT() *MockTagIteratorMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockTagIterator) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockTagIteratorMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockTagIterator)(nil).Close))
}

// Err mocks base method.
func (m *MockTagIterator) Err() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Err")
	ret0, _ := ret[0].(error)
	return ret0
}

// Err indicates an expected call of Err.
func (mr *MockTagIteratorMockRecorder) Err() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Err", reflect.TypeOf((*MockTagIterator)(nil).Err))
}

// Next mocks base method.
func (m *MockTagIterator) Next() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Next")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Next indicates an expected call of Next.
func (mr *MockTagIteratorMockRecorder) Next() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockTagIterator)(nil).Next))
}

// SeekGE mocks base method.
func (m *MockTagIterator) SeekGE(id graveler.TagID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SeekGE", id)
}

// SeekGE indicates an expected call of SeekGE.
func (mr *MockTagIteratorMockRecorder) SeekGE(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SeekGE", reflect.TypeOf((*MockTagIterator)(nil).SeekGE), id)
}

// Value mocks base method.
func (m *MockTagIterator) Value() *graveler.TagRecord {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Value")
	ret0, _ := ret[0].(*graveler.TagRecord)
	return ret0
}

// Value indicates an expected call of Value.
func (mr *MockTagIteratorMockRecorder) Value() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Value", reflect.TypeOf((*MockTagIterator)(nil).Value))
}

// MockCommitIterator is a mock of CommitIterator interface.
type MockCommitIterator struct {
	ctrl     *gomock.Controller
	recorder *MockCommitIteratorMockRecorder
}

// MockCommitIteratorMockRecorder is the mock recorder for MockCommitIterator.
type MockCommitIteratorMockRecorder struct {
	mock *MockCommitIterator
}

// NewMockCommitIterator creates a new mock instance.
func NewMockCommitIterator(ctrl *gomock.Controller) *MockCommitIterator {
	mock := &MockCommitIterator{ctrl: ctrl}
	mock.recorder = &MockCommitIteratorMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCommitIterator) EXPECT() *MockCommitIteratorMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockCommitIterator) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockCommitIteratorMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockCommitIterator)(nil).Close))
}

// Err mocks base method.
func (m *MockCommitIterator) Err() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Err")
	ret0, _ := ret[0].(error)
	return ret0
}

// Err indicates an expected call of Err.
func (mr *MockCommitIteratorMockRecorder) Err() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Err", reflect.TypeOf((*MockCommitIterator)(nil).Err))
}

// Next mocks base method.
func (m *MockCommitIterator) Next() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Next")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Next indicates an expected call of Next.
func (mr *MockCommitIteratorMockRecorder) Next() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockCommitIterator)(nil).Next))
}

// SeekGE mocks base method.
func (m *MockCommitIterator) SeekGE(id graveler.CommitID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SeekGE", id)
}

// SeekGE indicates an expected call of SeekGE.
func (mr *MockCommitIteratorMockRecorder) SeekGE(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SeekGE", reflect.TypeOf((*MockCommitIterator)(nil).SeekGE), id)
}

// Value mocks base method.
func (m *MockCommitIterator) Value() *graveler.CommitRecord {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Value")
	ret0, _ := ret[0].(*graveler.CommitRecord)
	return ret0
}

// Value indicates an expected call of Value.
func (mr *MockCommitIteratorMockRecorder) Value() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Value", reflect.TypeOf((*MockCommitIterator)(nil).Value))
}

// MockAddressTokenIterator is a mock of AddressTokenIterator interface.
type MockAddressTokenIterator struct {
	ctrl     *gomock.Controller
	recorder *MockAddressTokenIteratorMockRecorder
}

// MockAddressTokenIteratorMockRecorder is the mock recorder for MockAddressTokenIterator.
type MockAddressTokenIteratorMockRecorder struct {
	mock *MockAddressTokenIterator
}

// NewMockAddressTokenIterator creates a new mock instance.
func NewMockAddressTokenIterator(ctrl *gomock.Controller) *MockAddressTokenIterator {
	mock := &MockAddressTokenIterator{ctrl: ctrl}
	mock.recorder = &MockAddressTokenIteratorMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAddressTokenIterator) EXPECT() *MockAddressTokenIteratorMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockAddressTokenIterator) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockAddressTokenIteratorMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockAddressTokenIterator)(nil).Close))
}

// Err mocks base method.
func (m *MockAddressTokenIterator) Err() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Err")
	ret0, _ := ret[0].(error)
	return ret0
}

// Err indicates an expected call of Err.
func (mr *MockAddressTokenIteratorMockRecorder) Err() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Err", reflect.TypeOf((*MockAddressTokenIterator)(nil).Err))
}

// Next mocks base method.
func (m *MockAddressTokenIterator) Next() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Next")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Next indicates an expected call of Next.
func (mr *MockAddressTokenIteratorMockRecorder) Next() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockAddressTokenIterator)(nil).Next))
}

// SeekGE mocks base method.
func (m *MockAddressTokenIterator) SeekGE(address string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SeekGE", address)
}

// SeekGE indicates an expected call of SeekGE.
func (mr *MockAddressTokenIteratorMockRecorder) SeekGE(address interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SeekGE", reflect.TypeOf((*MockAddressTokenIterator)(nil).SeekGE), address)
}

// Value mocks base method.
func (m *MockAddressTokenIterator) Value() *graveler.LinkAddressData {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Value")
	ret0, _ := ret[0].(*graveler.LinkAddressData)
	return ret0
}

// Value indicates an expected call of Value.
func (mr *MockAddressTokenIteratorMockRecorder) Value() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Value", reflect.TypeOf((*MockAddressTokenIterator)(nil).Value))
}

// MockRefManager is a mock of RefManager interface.
type MockRefManager struct {
	ctrl     *gomock.Controller
	recorder *MockRefManagerMockRecorder
}

// MockRefManagerMockRecorder is the mock recorder for MockRefManager.
type MockRefManagerMockRecorder struct {
	mock *MockRefManager
}

// NewMockRefManager creates a new mock instance.
func NewMockRefManager(ctrl *gomock.Controller) *MockRefManager {
	mock := &MockRefManager{ctrl: ctrl}
	mock.recorder = &MockRefManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRefManager) EXPECT() *MockRefManagerMockRecorder {
	return m.recorder
}

// AddCommit mocks base method.
func (m *MockRefManager) AddCommit(ctx context.Context, repository *graveler.RepositoryRecord, commit graveler.Commit) (graveler.CommitID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddCommit", ctx, repository, commit)
	ret0, _ := ret[0].(graveler.CommitID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddCommit indicates an expected call of AddCommit.
func (mr *MockRefManagerMockRecorder) AddCommit(ctx, repository, commit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCommit", reflect.TypeOf((*MockRefManager)(nil).AddCommit), ctx, repository, commit)
}

// BranchUpdate mocks base method.
func (m *MockRefManager) BranchUpdate(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID, f graveler.BranchUpdateFunc) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BranchUpdate", ctx, repository, branchID, f)
	ret0, _ := ret[0].(error)
	return ret0
}

// BranchUpdate indicates an expected call of BranchUpdate.
func (mr *MockRefManagerMockRecorder) BranchUpdate(ctx, repository, branchID, f interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BranchUpdate", reflect.TypeOf((*MockRefManager)(nil).BranchUpdate), ctx, repository, branchID, f)
}

// CreateBareRepository mocks base method.
func (m *MockRefManager) CreateBareRepository(ctx context.Context, repositoryID graveler.RepositoryID, repository graveler.Repository) (*graveler.RepositoryRecord, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBareRepository", ctx, repositoryID, repository)
	ret0, _ := ret[0].(*graveler.RepositoryRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateBareRepository indicates an expected call of CreateBareRepository.
func (mr *MockRefManagerMockRecorder) CreateBareRepository(ctx, repositoryID, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBareRepository", reflect.TypeOf((*MockRefManager)(nil).CreateBareRepository), ctx, repositoryID, repository)
}

// CreateBranch mocks base method.
func (m *MockRefManager) CreateBranch(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID, branch graveler.Branch) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBranch", ctx, repository, branchID, branch)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateBranch indicates an expected call of CreateBranch.
func (mr *MockRefManagerMockRecorder) CreateBranch(ctx, repository, branchID, branch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBranch", reflect.TypeOf((*MockRefManager)(nil).CreateBranch), ctx, repository, branchID, branch)
}

// CreateRepository mocks base method.
func (m *MockRefManager) CreateRepository(ctx context.Context, repositoryID graveler.RepositoryID, repository graveler.Repository) (*graveler.RepositoryRecord, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRepository", ctx, repositoryID, repository)
	ret0, _ := ret[0].(*graveler.RepositoryRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRepository indicates an expected call of CreateRepository.
func (mr *MockRefManagerMockRecorder) CreateRepository(ctx, repositoryID, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRepository", reflect.TypeOf((*MockRefManager)(nil).CreateRepository), ctx, repositoryID, repository)
}

// CreateTag mocks base method.
func (m *MockRefManager) CreateTag(ctx context.Context, repository *graveler.RepositoryRecord, tagID graveler.TagID, commitID graveler.CommitID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTag", ctx, repository, tagID, commitID)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateTag indicates an expected call of CreateTag.
func (mr *MockRefManagerMockRecorder) CreateTag(ctx, repository, tagID, commitID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTag", reflect.TypeOf((*MockRefManager)(nil).CreateTag), ctx, repository, tagID, commitID)
}

// DeleteBranch mocks base method.
func (m *MockRefManager) DeleteBranch(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBranch", ctx, repository, branchID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteBranch indicates an expected call of DeleteBranch.
func (mr *MockRefManagerMockRecorder) DeleteBranch(ctx, repository, branchID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBranch", reflect.TypeOf((*MockRefManager)(nil).DeleteBranch), ctx, repository, branchID)
}

// DeleteExpiredLinkAddresses mocks base method.
func (m *MockRefManager) DeleteExpiredLinkAddresses(ctx context.Context, repository *graveler.RepositoryRecord) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteExpiredLinkAddresses", ctx, repository)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteExpiredLinkAddresses indicates an expected call of DeleteExpiredLinkAddresses.
func (mr *MockRefManagerMockRecorder) DeleteExpiredLinkAddresses(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExpiredLinkAddresses", reflect.TypeOf((*MockRefManager)(nil).DeleteExpiredLinkAddresses), ctx, repository)
}

// DeleteRepository mocks base method.
func (m *MockRefManager) DeleteRepository(ctx context.Context, repositoryID graveler.RepositoryID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRepository", ctx, repositoryID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteRepository indicates an expected call of DeleteRepository.
func (mr *MockRefManagerMockRecorder) DeleteRepository(ctx, repositoryID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRepository", reflect.TypeOf((*MockRefManager)(nil).DeleteRepository), ctx, repositoryID)
}

// DeleteTag mocks base method.
func (m *MockRefManager) DeleteTag(ctx context.Context, repository *graveler.RepositoryRecord, tagID graveler.TagID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTag", ctx, repository, tagID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTag indicates an expected call of DeleteTag.
func (mr *MockRefManagerMockRecorder) DeleteTag(ctx, repository, tagID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTag", reflect.TypeOf((*MockRefManager)(nil).DeleteTag), ctx, repository, tagID)
}

// FindMergeBase mocks base method.
func (m *MockRefManager) FindMergeBase(ctx context.Context, repository *graveler.RepositoryRecord, commitIDs ...graveler.CommitID) (*graveler.Commit, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, repository}
	for _, a := range commitIDs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindMergeBase", varargs...)
	ret0, _ := ret[0].(*graveler.Commit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindMergeBase indicates an expected call of FindMergeBase.
func (mr *MockRefManagerMockRecorder) FindMergeBase(ctx, repository interface{}, commitIDs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, repository}, commitIDs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindMergeBase", reflect.TypeOf((*MockRefManager)(nil).FindMergeBase), varargs...)
}

// GCBranchIterator mocks base method.
func (m *MockRefManager) GCBranchIterator(ctx context.Context, repository *graveler.RepositoryRecord) (graveler.BranchIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GCBranchIterator", ctx, repository)
	ret0, _ := ret[0].(graveler.BranchIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GCBranchIterator indicates an expected call of GCBranchIterator.
func (mr *MockRefManagerMockRecorder) GCBranchIterator(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GCBranchIterator", reflect.TypeOf((*MockRefManager)(nil).GCBranchIterator), ctx, repository)
}

// GCCommitIterator mocks base method.
func (m *MockRefManager) GCCommitIterator(ctx context.Context, repository *graveler.RepositoryRecord) (graveler.CommitIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GCCommitIterator", ctx, repository)
	ret0, _ := ret[0].(graveler.CommitIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GCCommitIterator indicates an expected call of GCCommitIterator.
func (mr *MockRefManagerMockRecorder) GCCommitIterator(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GCCommitIterator", reflect.TypeOf((*MockRefManager)(nil).GCCommitIterator), ctx, repository)
}

// GetBranch mocks base method.
func (m *MockRefManager) GetBranch(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID) (*graveler.Branch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBranch", ctx, repository, branchID)
	ret0, _ := ret[0].(*graveler.Branch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBranch indicates an expected call of GetBranch.
func (mr *MockRefManagerMockRecorder) GetBranch(ctx, repository, branchID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBranch", reflect.TypeOf((*MockRefManager)(nil).GetBranch), ctx, repository, branchID)
}

// GetCommit mocks base method.
func (m *MockRefManager) GetCommit(ctx context.Context, repository *graveler.RepositoryRecord, commitID graveler.CommitID) (*graveler.Commit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommit", ctx, repository, commitID)
	ret0, _ := ret[0].(*graveler.Commit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCommit indicates an expected call of GetCommit.
func (mr *MockRefManagerMockRecorder) GetCommit(ctx, repository, commitID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommit", reflect.TypeOf((*MockRefManager)(nil).GetCommit), ctx, repository, commitID)
}

// GetCommitByPrefix mocks base method.
func (m *MockRefManager) GetCommitByPrefix(ctx context.Context, repository *graveler.RepositoryRecord, prefix graveler.CommitID) (*graveler.Commit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommitByPrefix", ctx, repository, prefix)
	ret0, _ := ret[0].(*graveler.Commit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCommitByPrefix indicates an expected call of GetCommitByPrefix.
func (mr *MockRefManagerMockRecorder) GetCommitByPrefix(ctx, repository, prefix interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitByPrefix", reflect.TypeOf((*MockRefManager)(nil).GetCommitByPrefix), ctx, repository, prefix)
}

// GetRepository mocks base method.
func (m *MockRefManager) GetRepository(ctx context.Context, repositoryID graveler.RepositoryID) (*graveler.RepositoryRecord, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRepository", ctx, repositoryID)
	ret0, _ := ret[0].(*graveler.RepositoryRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRepository indicates an expected call of GetRepository.
func (mr *MockRefManagerMockRecorder) GetRepository(ctx, repositoryID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepository", reflect.TypeOf((*MockRefManager)(nil).GetRepository), ctx, repositoryID)
}

// GetTag mocks base method.
func (m *MockRefManager) GetTag(ctx context.Context, repository *graveler.RepositoryRecord, tagID graveler.TagID) (*graveler.CommitID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTag", ctx, repository, tagID)
	ret0, _ := ret[0].(*graveler.CommitID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTag indicates an expected call of GetTag.
func (mr *MockRefManagerMockRecorder) GetTag(ctx, repository, tagID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTag", reflect.TypeOf((*MockRefManager)(nil).GetTag), ctx, repository, tagID)
}

// IsLinkAddressExpired mocks base method.
func (m *MockRefManager) IsLinkAddressExpired(token *graveler.LinkAddressData) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsLinkAddressExpired", token)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsLinkAddressExpired indicates an expected call of IsLinkAddressExpired.
func (mr *MockRefManagerMockRecorder) IsLinkAddressExpired(token interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsLinkAddressExpired", reflect.TypeOf((*MockRefManager)(nil).IsLinkAddressExpired), token)
}

// ListBranches mocks base method.
func (m *MockRefManager) ListBranches(ctx context.Context, repository *graveler.RepositoryRecord) (graveler.BranchIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBranches", ctx, repository)
	ret0, _ := ret[0].(graveler.BranchIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBranches indicates an expected call of ListBranches.
func (mr *MockRefManagerMockRecorder) ListBranches(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBranches", reflect.TypeOf((*MockRefManager)(nil).ListBranches), ctx, repository)
}

// ListCommits mocks base method.
func (m *MockRefManager) ListCommits(ctx context.Context, repository *graveler.RepositoryRecord) (graveler.CommitIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommits", ctx, repository)
	ret0, _ := ret[0].(graveler.CommitIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCommits indicates an expected call of ListCommits.
func (mr *MockRefManagerMockRecorder) ListCommits(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommits", reflect.TypeOf((*MockRefManager)(nil).ListCommits), ctx, repository)
}

// ListLinkAddresses mocks base method.
func (m *MockRefManager) ListLinkAddresses(ctx context.Context, repository *graveler.RepositoryRecord) (graveler.AddressTokenIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLinkAddresses", ctx, repository)
	ret0, _ := ret[0].(graveler.AddressTokenIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLinkAddresses indicates an expected call of ListLinkAddresses.
func (mr *MockRefManagerMockRecorder) ListLinkAddresses(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLinkAddresses", reflect.TypeOf((*MockRefManager)(nil).ListLinkAddresses), ctx, repository)
}

// ListRepositories mocks base method.
func (m *MockRefManager) ListRepositories(ctx context.Context) (graveler.RepositoryIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRepositories", ctx)
	ret0, _ := ret[0].(graveler.RepositoryIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRepositories indicates an expected call of ListRepositories.
func (mr *MockRefManagerMockRecorder) ListRepositories(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRepositories", reflect.TypeOf((*MockRefManager)(nil).ListRepositories), ctx)
}

// ListTags mocks base method.
func (m *MockRefManager) ListTags(ctx context.Context, repository *graveler.RepositoryRecord) (graveler.TagIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTags", ctx, repository)
	ret0, _ := ret[0].(graveler.TagIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTags indicates an expected call of ListTags.
func (mr *MockRefManagerMockRecorder) ListTags(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTags", reflect.TypeOf((*MockRefManager)(nil).ListTags), ctx, repository)
}

// Log mocks base method.
func (m *MockRefManager) Log(ctx context.Context, repository *graveler.RepositoryRecord, commitID graveler.CommitID) (graveler.CommitIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Log", ctx, repository, commitID)
	ret0, _ := ret[0].(graveler.CommitIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Log indicates an expected call of Log.
func (mr *MockRefManagerMockRecorder) Log(ctx, repository, commitID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Log", reflect.TypeOf((*MockRefManager)(nil).Log), ctx, repository, commitID)
}

// ParseRef mocks base method.
func (m *MockRefManager) ParseRef(ref graveler.Ref) (graveler.RawRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParseRef", ref)
	ret0, _ := ret[0].(graveler.RawRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ParseRef indicates an expected call of ParseRef.
func (mr *MockRefManagerMockRecorder) ParseRef(ref interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ParseRef", reflect.TypeOf((*MockRefManager)(nil).ParseRef), ref)
}

// RemoveCommit mocks base method.
func (m *MockRefManager) RemoveCommit(ctx context.Context, repository *graveler.RepositoryRecord, commitID graveler.CommitID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveCommit", ctx, repository, commitID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveCommit indicates an expected call of RemoveCommit.
func (mr *MockRefManagerMockRecorder) RemoveCommit(ctx, repository, commitID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveCommit", reflect.TypeOf((*MockRefManager)(nil).RemoveCommit), ctx, repository, commitID)
}

// ResolveRawRef mocks base method.
func (m *MockRefManager) ResolveRawRef(ctx context.Context, repository *graveler.RepositoryRecord, rawRef graveler.RawRef) (*graveler.ResolvedRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolveRawRef", ctx, repository, rawRef)
	ret0, _ := ret[0].(*graveler.ResolvedRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResolveRawRef indicates an expected call of ResolveRawRef.
func (mr *MockRefManagerMockRecorder) ResolveRawRef(ctx, repository, rawRef interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveRawRef", reflect.TypeOf((*MockRefManager)(nil).ResolveRawRef), ctx, repository, rawRef)
}

// SetBranch mocks base method.
func (m *MockRefManager) SetBranch(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID, branch graveler.Branch) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetBranch", ctx, repository, branchID, branch)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetBranch indicates an expected call of SetBranch.
func (mr *MockRefManagerMockRecorder) SetBranch(ctx, repository, branchID, branch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBranch", reflect.TypeOf((*MockRefManager)(nil).SetBranch), ctx, repository, branchID, branch)
}

// SetLinkAddress mocks base method.
func (m *MockRefManager) SetLinkAddress(ctx context.Context, repository *graveler.RepositoryRecord, token string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLinkAddress", ctx, repository, token)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLinkAddress indicates an expected call of SetLinkAddress.
func (mr *MockRefManagerMockRecorder) SetLinkAddress(ctx, repository, token interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLinkAddress", reflect.TypeOf((*MockRefManager)(nil).SetLinkAddress), ctx, repository, token)
}

// VerifyLinkAddress mocks base method.
func (m *MockRefManager) VerifyLinkAddress(ctx context.Context, repository *graveler.RepositoryRecord, token string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyLinkAddress", ctx, repository, token)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyLinkAddress indicates an expected call of VerifyLinkAddress.
func (mr *MockRefManagerMockRecorder) VerifyLinkAddress(ctx, repository, token interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyLinkAddress", reflect.TypeOf((*MockRefManager)(nil).VerifyLinkAddress), ctx, repository, token)
}

// MockCommittedManager is a mock of CommittedManager interface.
type MockCommittedManager struct {
	ctrl     *gomock.Controller
	recorder *MockCommittedManagerMockRecorder
}

// MockCommittedManagerMockRecorder is the mock recorder for MockCommittedManager.
type MockCommittedManagerMockRecorder struct {
	mock *MockCommittedManager
}

// NewMockCommittedManager creates a new mock instance.
func NewMockCommittedManager(ctrl *gomock.Controller) *MockCommittedManager {
	mock := &MockCommittedManager{ctrl: ctrl}
	mock.recorder = &MockCommittedManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCommittedManager) EXPECT() *MockCommittedManagerMockRecorder {
	return m.recorder
}

// Commit mocks base method.
func (m *MockCommittedManager) Commit(ctx context.Context, ns graveler.StorageNamespace, baseMetaRangeID graveler.MetaRangeID, changes graveler.ValueIterator) (graveler.MetaRangeID, graveler.DiffSummary, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Commit", ctx, ns, baseMetaRangeID, changes)
	ret0, _ := ret[0].(graveler.MetaRangeID)
	ret1, _ := ret[1].(graveler.DiffSummary)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Commit indicates an expected call of Commit.
func (mr *MockCommittedManagerMockRecorder) Commit(ctx, ns, baseMetaRangeID, changes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockCommittedManager)(nil).Commit), ctx, ns, baseMetaRangeID, changes)
}

// Compare mocks base method.
func (m *MockCommittedManager) Compare(ctx context.Context, ns graveler.StorageNamespace, destination, source, base graveler.MetaRangeID) (graveler.DiffIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Compare", ctx, ns, destination, source, base)
	ret0, _ := ret[0].(graveler.DiffIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Compare indicates an expected call of Compare.
func (mr *MockCommittedManagerMockRecorder) Compare(ctx, ns, destination, source, base interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Compare", reflect.TypeOf((*MockCommittedManager)(nil).Compare), ctx, ns, destination, source, base)
}

// Diff mocks base method.
func (m *MockCommittedManager) Diff(ctx context.Context, ns graveler.StorageNamespace, left, right graveler.MetaRangeID) (graveler.DiffIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Diff", ctx, ns, left, right)
	ret0, _ := ret[0].(graveler.DiffIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Diff indicates an expected call of Diff.
func (mr *MockCommittedManagerMockRecorder) Diff(ctx, ns, left, right interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Diff", reflect.TypeOf((*MockCommittedManager)(nil).Diff), ctx, ns, left, right)
}

// Exists mocks base method.
func (m *MockCommittedManager) Exists(ctx context.Context, ns graveler.StorageNamespace, id graveler.MetaRangeID) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Exists", ctx, ns, id)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Exists indicates an expected call of Exists.
func (mr *MockCommittedManagerMockRecorder) Exists(ctx, ns, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockCommittedManager)(nil).Exists), ctx, ns, id)
}

// Get mocks base method.
func (m *MockCommittedManager) Get(ctx context.Context, ns graveler.StorageNamespace, rangeID graveler.MetaRangeID, key graveler.Key) (*graveler.Value, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, ns, rangeID, key)
	ret0, _ := ret[0].(*graveler.Value)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockCommittedManagerMockRecorder) Get(ctx, ns, rangeID, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockCommittedManager)(nil).Get), ctx, ns, rangeID, key)
}

// GetMetaRange mocks base method.
func (m *MockCommittedManager) GetMetaRange(ctx context.Context, ns graveler.StorageNamespace, metaRangeID graveler.MetaRangeID) (graveler.MetaRangeAddress, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetaRange", ctx, ns, metaRangeID)
	ret0, _ := ret[0].(graveler.MetaRangeAddress)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMetaRange indicates an expected call of GetMetaRange.
func (mr *MockCommittedManagerMockRecorder) GetMetaRange(ctx, ns, metaRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetaRange", reflect.TypeOf((*MockCommittedManager)(nil).GetMetaRange), ctx, ns, metaRangeID)
}

// GetRange mocks base method.
func (m *MockCommittedManager) GetRange(ctx context.Context, ns graveler.StorageNamespace, rangeID graveler.RangeID) (graveler.RangeAddress, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRange", ctx, ns, rangeID)
	ret0, _ := ret[0].(graveler.RangeAddress)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRange indicates an expected call of GetRange.
func (mr *MockCommittedManagerMockRecorder) GetRange(ctx, ns, rangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRange", reflect.TypeOf((*MockCommittedManager)(nil).GetRange), ctx, ns, rangeID)
}

// List mocks base method.
func (m *MockCommittedManager) List(ctx context.Context, ns graveler.StorageNamespace, rangeID graveler.MetaRangeID) (graveler.ValueIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, ns, rangeID)
	ret0, _ := ret[0].(graveler.ValueIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockCommittedManagerMockRecorder) List(ctx, ns, rangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockCommittedManager)(nil).List), ctx, ns, rangeID)
}

// Merge mocks base method.
func (m *MockCommittedManager) Merge(ctx context.Context, ns graveler.StorageNamespace, destination, source, base graveler.MetaRangeID, strategy graveler.MergeStrategy) (graveler.MetaRangeID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Merge", ctx, ns, destination, source, base, strategy)
	ret0, _ := ret[0].(graveler.MetaRangeID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Merge indicates an expected call of Merge.
func (mr *MockCommittedManagerMockRecorder) Merge(ctx, ns, destination, source, base, strategy interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Merge", reflect.TypeOf((*MockCommittedManager)(nil).Merge), ctx, ns, destination, source, base, strategy)
}

// WriteMetaRange mocks base method.
func (m *MockCommittedManager) WriteMetaRange(ctx context.Context, ns graveler.StorageNamespace, ranges []*graveler.RangeInfo) (*graveler.MetaRangeInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteMetaRange", ctx, ns, ranges)
	ret0, _ := ret[0].(*graveler.MetaRangeInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteMetaRange indicates an expected call of WriteMetaRange.
func (mr *MockCommittedManagerMockRecorder) WriteMetaRange(ctx, ns, ranges interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteMetaRange", reflect.TypeOf((*MockCommittedManager)(nil).WriteMetaRange), ctx, ns, ranges)
}

// WriteMetaRangeByIterator mocks base method.
func (m *MockCommittedManager) WriteMetaRangeByIterator(ctx context.Context, ns graveler.StorageNamespace, it graveler.ValueIterator, metadata graveler.Metadata) (*graveler.MetaRangeID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteMetaRangeByIterator", ctx, ns, it, metadata)
	ret0, _ := ret[0].(*graveler.MetaRangeID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteMetaRangeByIterator indicates an expected call of WriteMetaRangeByIterator.
func (mr *MockCommittedManagerMockRecorder) WriteMetaRangeByIterator(ctx, ns, it, metadata interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteMetaRangeByIterator", reflect.TypeOf((*MockCommittedManager)(nil).WriteMetaRangeByIterator), ctx, ns, it, metadata)
}

// WriteRange mocks base method.
func (m *MockCommittedManager) WriteRange(ctx context.Context, ns graveler.StorageNamespace, it graveler.ValueIterator) (*graveler.RangeInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteRange", ctx, ns, it)
	ret0, _ := ret[0].(*graveler.RangeInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteRange indicates an expected call of WriteRange.
func (mr *MockCommittedManagerMockRecorder) WriteRange(ctx, ns, it interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteRange", reflect.TypeOf((*MockCommittedManager)(nil).WriteRange), ctx, ns, it)
}

// MockStagingManager is a mock of StagingManager interface.
type MockStagingManager struct {
	ctrl     *gomock.Controller
	recorder *MockStagingManagerMockRecorder
}

// MockStagingManagerMockRecorder is the mock recorder for MockStagingManager.
type MockStagingManagerMockRecorder struct {
	mock *MockStagingManager
}

// NewMockStagingManager creates a new mock instance.
func NewMockStagingManager(ctrl *gomock.Controller) *MockStagingManager {
	mock := &MockStagingManager{ctrl: ctrl}
	mock.recorder = &MockStagingManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockStagingManager) EXPECT() *MockStagingManagerMockRecorder {
	return m.recorder
}

// Drop mocks base method.
func (m *MockStagingManager) Drop(ctx context.Context, st graveler.StagingToken) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Drop", ctx, st)
	ret0, _ := ret[0].(error)
	return ret0
}

// Drop indicates an expected call of Drop.
func (mr *MockStagingManagerMockRecorder) Drop(ctx, st interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Drop", reflect.TypeOf((*MockStagingManager)(nil).Drop), ctx, st)
}

// DropAsync mocks base method.
func (m *MockStagingManager) DropAsync(ctx context.Context, st graveler.StagingToken) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DropAsync", ctx, st)
	ret0, _ := ret[0].(error)
	return ret0
}

// DropAsync indicates an expected call of DropAsync.
func (mr *MockStagingManagerMockRecorder) DropAsync(ctx, st interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropAsync", reflect.TypeOf((*MockStagingManager)(nil).DropAsync), ctx, st)
}

// DropByPrefix mocks base method.
func (m *MockStagingManager) DropByPrefix(ctx context.Context, st graveler.StagingToken, prefix graveler.Key) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DropByPrefix", ctx, st, prefix)
	ret0, _ := ret[0].(error)
	return ret0
}

// DropByPrefix indicates an expected call of DropByPrefix.
func (mr *MockStagingManagerMockRecorder) DropByPrefix(ctx, st, prefix interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropByPrefix", reflect.TypeOf((*MockStagingManager)(nil).DropByPrefix), ctx, st, prefix)
}

// DropKey mocks base method.
func (m *MockStagingManager) DropKey(ctx context.Context, st graveler.StagingToken, key graveler.Key) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DropKey", ctx, st, key)
	ret0, _ := ret[0].(error)
	return ret0
}

// DropKey indicates an expected call of DropKey.
func (mr *MockStagingManagerMockRecorder) DropKey(ctx, st, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropKey", reflect.TypeOf((*MockStagingManager)(nil).DropKey), ctx, st, key)
}

// Get mocks base method.
func (m *MockStagingManager) Get(ctx context.Context, st graveler.StagingToken, key graveler.Key) (*graveler.Value, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, st, key)
	ret0, _ := ret[0].(*graveler.Value)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockStagingManagerMockRecorder) Get(ctx, st, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStagingManager)(nil).Get), ctx, st, key)
}

// List mocks base method.
func (m *MockStagingManager) List(ctx context.Context, st graveler.StagingToken, batchSize int) (graveler.ValueIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, st, batchSize)
	ret0, _ := ret[0].(graveler.ValueIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockStagingManagerMockRecorder) List(ctx, st, batchSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockStagingManager)(nil).List), ctx, st, batchSize)
}

// Set mocks base method.
func (m *MockStagingManager) Set(ctx context.Context, st graveler.StagingToken, key graveler.Key, value *graveler.Value, requireExists bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Set", ctx, st, key, value, requireExists)
	ret0, _ := ret[0].(error)
	return ret0
}

// Set indicates an expected call of Set.
func (mr *MockStagingManagerMockRecorder) Set(ctx, st, key, value, requireExists interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockStagingManager)(nil).Set), ctx, st, key, value, requireExists)
}

// Update mocks base method.
func (m *MockStagingManager) Update(ctx context.Context, st graveler.StagingToken, key graveler.Key, updateFunc graveler.ValueUpdateFunc) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, st, key, updateFunc)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockStagingManagerMockRecorder) Update(ctx, st, key, updateFunc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockStagingManager)(nil).Update), ctx, st, key, updateFunc)
}

// MockBranchLocker is a mock of BranchLocker interface.
type MockBranchLocker struct {
	ctrl     *gomock.Controller
	recorder *MockBranchLockerMockRecorder
}

// MockBranchLockerMockRecorder is the mock recorder for MockBranchLocker.
type MockBranchLockerMockRecorder struct {
	mock *MockBranchLocker
}

// NewMockBranchLocker creates a new mock instance.
func NewMockBranchLocker(ctrl *gomock.Controller) *MockBranchLocker {
	mock := &MockBranchLocker{ctrl: ctrl}
	mock.recorder = &MockBranchLockerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBranchLocker) EXPECT() *MockBranchLockerMockRecorder {
	return m.recorder
}

// MetadataUpdater mocks base method.
func (m *MockBranchLocker) MetadataUpdater(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID, lockeFn graveler.BranchLockerFunc) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MetadataUpdater", ctx, repository, branchID, lockeFn)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MetadataUpdater indicates an expected call of MetadataUpdater.
func (mr *MockBranchLockerMockRecorder) MetadataUpdater(ctx, repository, branchID, lockeFn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetadataUpdater", reflect.TypeOf((*MockBranchLocker)(nil).MetadataUpdater), ctx, repository, branchID, lockeFn)
}

// Writer mocks base method.
func (m *MockBranchLocker) Writer(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID, lockedFn graveler.BranchLockerFunc) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Writer", ctx, repository, branchID, lockedFn)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Writer indicates an expected call of Writer.
func (mr *MockBranchLockerMockRecorder) Writer(ctx, repository, branchID, lockedFn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Writer", reflect.TypeOf((*MockBranchLocker)(nil).Writer), ctx, repository, branchID, lockedFn)
}

// MockGarbageCollectionManager is a mock of GarbageCollectionManager interface.
type MockGarbageCollectionManager struct {
	ctrl     *gomock.Controller
	recorder *MockGarbageCollectionManagerMockRecorder
}

// MockGarbageCollectionManagerMockRecorder is the mock recorder for MockGarbageCollectionManager.
type MockGarbageCollectionManagerMockRecorder struct {
	mock *MockGarbageCollectionManager
}

// NewMockGarbageCollectionManager creates a new mock instance.
func NewMockGarbageCollectionManager(ctrl *gomock.Controller) *MockGarbageCollectionManager {
	mock := &MockGarbageCollectionManager{ctrl: ctrl}
	mock.recorder = &MockGarbageCollectionManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockGarbageCollectionManager) EXPECT() *MockGarbageCollectionManagerMockRecorder {
	return m.recorder
}

// GetAddressesLocation mocks base method.
func (m *MockGarbageCollectionManager) GetAddressesLocation(sn graveler.StorageNamespace) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAddressesLocation", sn)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAddressesLocation indicates an expected call of GetAddressesLocation.
func (mr *MockGarbageCollectionManagerMockRecorder) GetAddressesLocation(sn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddressesLocation", reflect.TypeOf((*MockGarbageCollectionManager)(nil).GetAddressesLocation), sn)
}

// GetCommitsCSVLocation mocks base method.
func (m *MockGarbageCollectionManager) GetCommitsCSVLocation(runID string, sn graveler.StorageNamespace) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommitsCSVLocation", runID, sn)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCommitsCSVLocation indicates an expected call of GetCommitsCSVLocation.
func (mr *MockGarbageCollectionManagerMockRecorder) GetCommitsCSVLocation(runID, sn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitsCSVLocation", reflect.TypeOf((*MockGarbageCollectionManager)(nil).GetCommitsCSVLocation), runID, sn)
}

// GetRules mocks base method.
func (m *MockGarbageCollectionManager) GetRules(ctx context.Context, storageNamespace graveler.StorageNamespace) (*graveler.GarbageCollectionRules, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRules", ctx, storageNamespace)
	ret0, _ := ret[0].(*graveler.GarbageCollectionRules)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRules indicates an expected call of GetRules.
func (mr *MockGarbageCollectionManagerMockRecorder) GetRules(ctx, storageNamespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRules", reflect.TypeOf((*MockGarbageCollectionManager)(nil).GetRules), ctx, storageNamespace)
}

// GetRunExpiredCommits mocks base method.
func (m *MockGarbageCollectionManager) GetRunExpiredCommits(ctx context.Context, storageNamespace graveler.StorageNamespace, runID string) ([]graveler.CommitID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRunExpiredCommits", ctx, storageNamespace, runID)
	ret0, _ := ret[0].([]graveler.CommitID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRunExpiredCommits indicates an expected call of GetRunExpiredCommits.
func (mr *MockGarbageCollectionManagerMockRecorder) GetRunExpiredCommits(ctx, storageNamespace, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRunExpiredCommits", reflect.TypeOf((*MockGarbageCollectionManager)(nil).GetRunExpiredCommits), ctx, storageNamespace, runID)
}

// GetUncommittedLocation mocks base method.
func (m *MockGarbageCollectionManager) GetUncommittedLocation(runID string, sn graveler.StorageNamespace) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUncommittedLocation", runID, sn)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUncommittedLocation indicates an expected call of GetUncommittedLocation.
func (mr *MockGarbageCollectionManagerMockRecorder) GetUncommittedLocation(runID, sn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUncommittedLocation", reflect.TypeOf((*MockGarbageCollectionManager)(nil).GetUncommittedLocation), runID, sn)
}

// NewID mocks base method.
func (m *MockGarbageCollectionManager) NewID() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewID")
	ret0, _ := ret[0].(string)
	return ret0
}

// NewID indicates an expected call of NewID.
func (mr *MockGarbageCollectionManagerMockRecorder) NewID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewID", reflect.TypeOf((*MockGarbageCollectionManager)(nil).NewID))
}

// SaveGarbageCollectionCommits mocks base method.
func (m *MockGarbageCollectionManager) SaveGarbageCollectionCommits(ctx context.Context, repository *graveler.RepositoryRecord, rules *graveler.GarbageCollectionRules, previouslyExpiredCommits []graveler.CommitID) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveGarbageCollectionCommits", ctx, repository, rules, previouslyExpiredCommits)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SaveGarbageCollectionCommits indicates an expected call of SaveGarbageCollectionCommits.
func (mr *MockGarbageCollectionManagerMockRecorder) SaveGarbageCollectionCommits(ctx, repository, rules, previouslyExpiredCommits interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveGarbageCollectionCommits", reflect.TypeOf((*MockGarbageCollectionManager)(nil).SaveGarbageCollectionCommits), ctx, repository, rules, previouslyExpiredCommits)
}

// SaveGarbageCollectionUncommitted mocks base method.
func (m *MockGarbageCollectionManager) SaveGarbageCollectionUncommitted(ctx context.Context, repository *graveler.RepositoryRecord, filename, runID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveGarbageCollectionUncommitted", ctx, repository, filename, runID)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveGarbageCollectionUncommitted indicates an expected call of SaveGarbageCollectionUncommitted.
func (mr *MockGarbageCollectionManagerMockRecorder) SaveGarbageCollectionUncommitted(ctx, repository, filename, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveGarbageCollectionUncommitted", reflect.TypeOf((*MockGarbageCollectionManager)(nil).SaveGarbageCollectionUncommitted), ctx, repository, filename, runID)
}

// SaveRules mocks base method.
func (m *MockGarbageCollectionManager) SaveRules(ctx context.Context, storageNamespace graveler.StorageNamespace, rules *graveler.GarbageCollectionRules) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveRules", ctx, storageNamespace, rules)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveRules indicates an expected call of SaveRules.
func (mr *MockGarbageCollectionManagerMockRecorder) SaveRules(ctx, storageNamespace, rules interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveRules", reflect.TypeOf((*MockGarbageCollectionManager)(nil).SaveRules), ctx, storageNamespace, rules)
}

// MockProtectedBranchesManager is a mock of ProtectedBranchesManager interface.
type MockProtectedBranchesManager struct {
	ctrl     *gomock.Controller
	recorder *MockProtectedBranchesManagerMockRecorder
}

// MockProtectedBranchesManagerMockRecorder is the mock recorder for MockProtectedBranchesManager.
type MockProtectedBranchesManagerMockRecorder struct {
	mock *MockProtectedBranchesManager
}

// NewMockProtectedBranchesManager creates a new mock instance.
func NewMockProtectedBranchesManager(ctrl *gomock.Controller) *MockProtectedBranchesManager {
	mock := &MockProtectedBranchesManager{ctrl: ctrl}
	mock.recorder = &MockProtectedBranchesManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockProtectedBranchesManager) EXPECT() *MockProtectedBranchesManagerMockRecorder {
	return m.recorder
}

// Add mocks base method.
func (m *MockProtectedBranchesManager) Add(ctx context.Context, repository *graveler.RepositoryRecord, branchNamePattern string, blockedActions []graveler.BranchProtectionBlockedAction) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Add", ctx, repository, branchNamePattern, blockedActions)
	ret0, _ := ret[0].(error)
	return ret0
}

// Add indicates an expected call of Add.
func (mr *MockProtectedBranchesManagerMockRecorder) Add(ctx, repository, branchNamePattern, blockedActions interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockProtectedBranchesManager)(nil).Add), ctx, repository, branchNamePattern, blockedActions)
}

// Delete mocks base method.
func (m *MockProtectedBranchesManager) Delete(ctx context.Context, repository *graveler.RepositoryRecord, branchNamePattern string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, repository, branchNamePattern)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockProtectedBranchesManagerMockRecorder) Delete(ctx, repository, branchNamePattern interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockProtectedBranchesManager)(nil).Delete), ctx, repository, branchNamePattern)
}

// Get mocks base method.
func (m *MockProtectedBranchesManager) Get(ctx context.Context, repository *graveler.RepositoryRecord, branchNamePattern string) ([]graveler.BranchProtectionBlockedAction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, repository, branchNamePattern)
	ret0, _ := ret[0].([]graveler.BranchProtectionBlockedAction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockProtectedBranchesManagerMockRecorder) Get(ctx, repository, branchNamePattern interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockProtectedBranchesManager)(nil).Get), ctx, repository, branchNamePattern)
}

// GetRules mocks base method.
func (m *MockProtectedBranchesManager) GetRules(ctx context.Context, repository *graveler.RepositoryRecord) (*graveler.BranchProtectionRules, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRules", ctx, repository)
	ret0, _ := ret[0].(*graveler.BranchProtectionRules)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRules indicates an expected call of GetRules.
func (mr *MockProtectedBranchesManagerMockRecorder) GetRules(ctx, repository interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRules", reflect.TypeOf((*MockProtectedBranchesManager)(nil).GetRules), ctx, repository)
}

// IsBlocked mocks base method.
func (m *MockProtectedBranchesManager) IsBlocked(ctx context.Context, repository *graveler.RepositoryRecord, branchID graveler.BranchID, action graveler.BranchProtectionBlockedAction) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsBlocked", ctx, repository, branchID, action)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsBlocked indicates an expected call of IsBlocked.
func (mr *MockProtectedBranchesManagerMockRecorder) IsBlocked(ctx, repository, branchID, action interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsBlocked", reflect.TypeOf((*MockProtectedBranchesManager)(nil).IsBlocked), ctx, repository, branchID, action)
}