func (m *MockExecutionManager) CompleteReplicationTask(request *CompleteReplicationTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteReplicationTask", request)
	ret0, _ := ret[0].(error)
	return ret0
}
CompleteReplicationTask mocks base method.
package persistence
import (
	reflect "reflect"
	gomock "github.com/golang/mock/gomock"
)
type MockCloseable struct {
	ctrl     *gomock.Controller
	recorder *MockCloseableMockRecorder
}
type MockCloseableMockRecorder struct {
	mock *MockCloseable
}
func NewMockCloseable(ctrl *gomock.Controller) *MockCloseable {
	mock := &MockCloseable{ctrl: ctrl}
	mock.recorder = &MockCloseableMockRecorder{mock}
	return mock
}
func (m *MockCloseable) EXPECT() *MockCloseableMockRecorder {
	return m.recorder
}
func (m *MockCloseable) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}
func (mr *MockCloseableMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockCloseable)(nil).Close))
}
type MockShardManager struct {
	ctrl     *gomock.Controller
	recorder *MockShardManagerMockRecorder
}
type MockShardManagerMockRecorder struct {
	mock *MockShardManager
}
func NewMockShardManager(ctrl *gomock.Controller) *MockShardManager {
	mock := &MockShardManager{ctrl: ctrl}
	mock.recorder = &MockShardManagerMockRecorder{mock}
	return mock
}
func (m *MockShardManager) EXPECT() *MockShardManagerMockRecorder {
	return m.recorder
}
func (m *MockShardManager) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}
func (mr *MockShardManagerMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockShardManager)(nil).Close))
}
func (m *MockShardManager) CreateShard(request *CreateShardRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateShard", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockShardManagerMockRecorder) CreateShard(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateShard", reflect.TypeOf((*MockShardManager)(nil).CreateShard), request)
}
func (m *MockShardManager) GetName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetName")
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockShardManagerMockRecorder) GetName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockShardManager)(nil).GetName))
}
func (m *MockShardManager) GetShard(request *GetShardRequest) (*GetShardResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetShard", request)
	ret0, _ := ret[0].(*GetShardResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockShardManagerMockRecorder) GetShard(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShard", reflect.TypeOf((*MockShardManager)(nil).GetShard), request)
}
func (m *MockShardManager) UpdateShard(request *UpdateShardRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateShard", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockShardManagerMockRecorder) UpdateShard(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateShard", reflect.TypeOf((*MockShardManager)(nil).UpdateShard), request)
}
type MockExecutionManager struct {
	ctrl     *gomock.Controller
	recorder *MockExecutionManagerMockRecorder
}
type MockExecutionManagerMockRecorder struct {
	mock *MockExecutionManager
}
func NewMockExecutionManager(ctrl *gomock.Controller) *MockExecutionManager {
	mock := &MockExecutionManager{ctrl: ctrl}
	mock.recorder = &MockExecutionManagerMockRecorder{mock}
	return mock
}
func (m *MockExecutionManager) EXPECT() *MockExecutionManagerMockRecorder {
	return m.recorder
}
func (m *MockExecutionManager) AddTasks(request *AddTasksRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTasks", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExecutionManagerMockRecorder) AddTasks(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTasks", reflect.TypeOf((*MockExecutionManager)(nil).AddTasks), request)
}
func (m *MockExecutionManager) AppendHistoryNodes(request *AppendHistoryNodesRequest) (*AppendHistoryNodesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppendHistoryNodes", request)
	ret0, _ := ret[0].(*AppendHistoryNodesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockExecutionManagerMockRecorder) AppendHistoryNodes(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendHistoryNodes", reflect.TypeOf((*MockExecutionManager)(nil).AppendHistoryNodes), request)
}
func (m *MockExecutionManager) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}
func (mr *MockExecutionManagerMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockExecutionManager)(nil).Close))
}