common/persistence/dataManagerInterfaces_mock.go

// The MIT License (MIT)

// Copyright (c) 2017-2020 Uber Technologies Inc.

// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/uber/cadence/common/persistence (interfaces: Task,ShardManager,ExecutionManager,ExecutionManagerFactory,TaskManager,HistoryManager,DomainManager,QueueManager,ConfigStoreManager)

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

import (
	context "context"
	reflect "reflect"
	time "time"

	gomock "github.com/golang/mock/gomock"
)

// MockTask is a mock of Task interface.
type MockTask struct {
	ctrl     *gomock.Controller
	recorder *MockTaskMockRecorder
}

// MockTaskMockRecorder is the mock recorder for MockTask.
type MockTaskMockRecorder struct {
	mock *MockTask
}

// NewMockTask creates a new mock instance.
func NewMockTask(ctrl *gomock.Controller) *MockTask {
	mock := &MockTask{ctrl: ctrl}
	mock.recorder = &MockTaskMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// GetVisibilityTimestamp mocks base method.
func (m *MockTask) GetVisibilityTimestamp() time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVisibilityTimestamp")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

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

// SetTaskID mocks base method.
func (m *MockTask) SetTaskID(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTaskID", arg0)
}

// SetTaskID indicates an expected call of SetTaskID.
func (mr *MockTaskMockRecorder) SetTaskID(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTaskID", reflect.TypeOf((*MockTask)(nil).SetTaskID), arg0)
}

// SetVersion mocks base method.
func (m *MockTask) SetVersion(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetVersion", arg0)
}

// SetVersion indicates an expected call of SetVersion.
func (mr *MockTaskMockRecorder) SetVersion(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVersion", reflect.TypeOf((*MockTask)(nil).SetVersion), arg0)
}

// SetVisibilityTimestamp mocks base method.
func (m *MockTask) SetVisibilityTimestamp(arg0 time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetVisibilityTimestamp", arg0)
}

// SetVisibilityTimestamp indicates an expected call of SetVisibilityTimestamp.
func (mr *MockTaskMockRecorder) SetVisibilityTimestamp(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVisibilityTimestamp", reflect.TypeOf((*MockTask)(nil).SetVisibilityTimestamp), arg0)
}

// MockShardManager is a mock of ShardManager interface.
type MockShardManager struct {
	ctrl     *gomock.Controller
	recorder *MockShardManagerMockRecorder
}

// MockShardManagerMockRecorder is the mock recorder for MockShardManager.
type MockShardManagerMockRecorder struct {
	mock *MockShardManager
}

// NewMockShardManager creates a new mock instance.
func NewMockShardManager(ctrl *gomock.Controller) *MockShardManager {
	mock := &MockShardManager{ctrl: ctrl}
	mock.recorder = &MockShardManagerMockRecorder{mock}
	return mock
}

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

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

// Close indicates an expected call of 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))
}

// CreateShard mocks base method.
func (m *MockShardManager) CreateShard(arg0 context.Context, arg1 *CreateShardRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateShard", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateShard indicates an expected call of CreateShard.
func (mr *MockShardManagerMockRecorder) CreateShard(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateShard", reflect.TypeOf((*MockShardManager)(nil).CreateShard), arg0, arg1)
}

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

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

// GetShard mocks base method.
func (m *MockShardManager) GetShard(arg0 context.Context, arg1 *GetShardRequest) (*GetShardResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetShard", arg0, arg1)
	ret0, _ := ret[0].(*GetShardResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetShard indicates an expected call of GetShard.
func (mr *MockShardManagerMockRecorder) GetShard(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShard", reflect.TypeOf((*MockShardManager)(nil).GetShard), arg0, arg1)
}

// UpdateShard mocks base method.
func (m *MockShardManager) UpdateShard(arg0 context.Context, arg1 *UpdateShardRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateShard", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateShard indicates an expected call of UpdateShard.
func (mr *MockShardManagerMockRecorder) UpdateShard(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateShard", reflect.TypeOf((*MockShardManager)(nil).UpdateShard), arg0, arg1)
}

// MockExecutionManager is a mock of ExecutionManager interface.
type MockExecutionManager struct {
	ctrl     *gomock.Controller
	recorder *MockExecutionManagerMockRecorder
}

// MockExecutionManagerMockRecorder is the mock recorder for MockExecutionManager.
type MockExecutionManagerMockRecorder struct {
	mock *MockExecutionManager
}

// NewMockExecutionManager creates a new mock instance.
func NewMockExecutionManager(ctrl *gomock.Controller) *MockExecutionManager {
	mock := &MockExecutionManager{ctrl: ctrl}
	mock.recorder = &MockExecutionManagerMockRecorder{mock}
	return mock
}

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

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

// Close indicates an expected call of 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))
}

// CompleteCrossClusterTask mocks base method.
func (m *MockExecutionManager) CompleteCrossClusterTask(arg0 context.Context, arg1 *CompleteCrossClusterTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteCrossClusterTask", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CompleteCrossClusterTask indicates an expected call of CompleteCrossClusterTask.
func (mr *MockExecutionManagerMockRecorder) CompleteCrossClusterTask(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteCrossClusterTask", reflect.TypeOf((*MockExecutionManager)(nil).CompleteCrossClusterTask), arg0, arg1)
}

// CompleteReplicationTask mocks base method.
func (m *MockExecutionManager) CompleteReplicationTask(arg0 context.Context, arg1 *CompleteReplicationTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteReplicationTask", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CompleteReplicationTask indicates an expected call of CompleteReplicationTask.
func (mr *MockExecutionManagerMockRecorder) CompleteReplicationTask(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteReplicationTask", reflect.TypeOf((*MockExecutionManager)(nil).CompleteReplicationTask), arg0, arg1)
}

// CompleteTimerTask mocks base method.
func (m *MockExecutionManager) CompleteTimerTask(arg0 context.Context, arg1 *CompleteTimerTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteTimerTask", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CompleteTimerTask indicates an expected call of CompleteTimerTask.
func (mr *MockExecutionManagerMockRecorder) CompleteTimerTask(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTimerTask", reflect.TypeOf((*MockExecutionManager)(nil).CompleteTimerTask), arg0, arg1)
}

// CompleteTransferTask mocks base method.
func (m *MockExecutionManager) CompleteTransferTask(arg0 context.Context, arg1 *CompleteTransferTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteTransferTask", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CompleteTransferTask indicates an expected call of CompleteTransferTask.
func (mr *MockExecutionManagerMockRecorder) CompleteTransferTask(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTransferTask", reflect.TypeOf((*MockExecutionManager)(nil).CompleteTransferTask), arg0, arg1)
}

// ConflictResolveWorkflowExecution mocks base method.
func (m *MockExecutionManager) ConflictResolveWorkflowExecution(arg0 context.Context, arg1 *ConflictResolveWorkflowExecutionRequest) (*ConflictResolveWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConflictResolveWorkflowExecution", arg0, arg1)
	ret0, _ := ret[0].(*ConflictResolveWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConflictResolveWorkflowExecution indicates an expected call of ConflictResolveWorkflowExecution.
func (mr *MockExecutionManagerMockRecorder) ConflictResolveWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConflictResolveWorkflowExecution", reflect.TypeOf((*MockExecutionManager)(nil).ConflictResolveWorkflowExecution), arg0, arg1)
}

// CreateFailoverMarkerTasks mocks base method.
func (m *MockExecutionManager) CreateFailoverMarkerTasks(arg0 context.Context, arg1 *CreateFailoverMarkersRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFailoverMarkerTasks", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateFailoverMarkerTasks indicates an expected call of CreateFailoverMarkerTasks.
func (mr *MockExecutionManagerMockRecorder) CreateFailoverMarkerTasks(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFailoverMarkerTasks", reflect.TypeOf((*MockExecutionManager)(nil).CreateFailoverMarkerTasks), arg0, arg1)
}

// CreateWorkflowExecution mocks base method.
func (m *MockExecutionManager) CreateWorkflowExecution(arg0 context.Context, arg1 *CreateWorkflowExecutionRequest) (*CreateWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWorkflowExecution", arg0, arg1)
	ret0, _ := ret[0].(*CreateWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateWorkflowExecution indicates an expected call of CreateWorkflowExecution.
func (mr *MockExecutionManagerMockRecorder) CreateWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkflowExecution", reflect.TypeOf((*MockExecutionManager)(nil).CreateWorkflowExecution), arg0, arg1)
}

// DeleteCurrentWorkflowExecution mocks base method.
func (m *MockExecutionManager) DeleteCurrentWorkflowExecution(arg0 context.Context, arg1 *DeleteCurrentWorkflowExecutionRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCurrentWorkflowExecution", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCurrentWorkflowExecution indicates an expected call of DeleteCurrentWorkflowExecution.
func (mr *MockExecutionManagerMockRecorder) DeleteCurrentWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCurrentWorkflowExecution", reflect.TypeOf((*MockExecutionManager)(nil).DeleteCurrentWorkflowExecution), arg0, arg1)
}

// DeleteReplicationTaskFromDLQ mocks base method.
func (m *MockExecutionManager) DeleteReplicationTaskFromDLQ(arg0 context.Context, arg1 *DeleteReplicationTaskFromDLQRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReplicationTaskFromDLQ", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteReplicationTaskFromDLQ indicates an expected call of DeleteReplicationTaskFromDLQ.
func (mr *MockExecutionManagerMockRecorder) DeleteReplicationTaskFromDLQ(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationTaskFromDLQ", reflect.TypeOf((*MockExecutionManager)(nil).DeleteReplicationTaskFromDLQ), arg0, arg1)
}

// DeleteWorkflowExecution mocks base method.
func (m *MockExecutionManager) DeleteWorkflowExecution(arg0 context.Context, arg1 *DeleteWorkflowExecutionRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkflowExecution", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteWorkflowExecution indicates an expected call of DeleteWorkflowExecution.
func (mr *MockExecutionManagerMockRecorder) DeleteWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkflowExecution", reflect.TypeOf((*MockExecutionManager)(nil).DeleteWorkflowExecution), arg0, arg1)
}

// GetCrossClusterTasks mocks base method.
func (m *MockExecutionManager) GetCrossClusterTasks(arg0 context.Context, arg1 *GetCrossClusterTasksRequest) (*GetCrossClusterTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCrossClusterTasks", arg0, arg1)
	ret0, _ := ret[0].(*GetCrossClusterTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCrossClusterTasks indicates an expected call of GetCrossClusterTasks.
func (mr *MockExecutionManagerMockRecorder) GetCrossClusterTasks(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCrossClusterTasks", reflect.TypeOf((*MockExecutionManager)(nil).GetCrossClusterTasks), arg0, arg1)
}

// GetCurrentExecution mocks base method.
func (m *MockExecutionManager) GetCurrentExecution(arg0 context.Context, arg1 *GetCurrentExecutionRequest) (*GetCurrentExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentExecution", arg0, arg1)
	ret0, _ := ret[0].(*GetCurrentExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCurrentExecution indicates an expected call of GetCurrentExecution.
func (mr *MockExecutionManagerMockRecorder) GetCurrentExecution(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentExecution", reflect.TypeOf((*MockExecutionManager)(nil).GetCurrentExecution), arg0, arg1)
}

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

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

// GetReplicationDLQSize mocks base method.
func (m *MockExecutionManager) GetReplicationDLQSize(arg0 context.Context, arg1 *GetReplicationDLQSizeRequest) (*GetReplicationDLQSizeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicationDLQSize", arg0, arg1)
	ret0, _ := ret[0].(*GetReplicationDLQSizeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReplicationDLQSize indicates an expected call of GetReplicationDLQSize.
func (mr *MockExecutionManagerMockRecorder) GetReplicationDLQSize(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReplicationDLQSize", reflect.TypeOf((*MockExecutionManager)(nil).GetReplicationDLQSize), arg0, arg1)
}

// GetReplicationTasks mocks base method.
func (m *MockExecutionManager) GetReplicationTasks(arg0 context.Context, arg1 *GetReplicationTasksRequest) (*GetReplicationTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicationTasks", arg0, arg1)
	ret0, _ := ret[0].(*GetReplicationTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReplicationTasks indicates an expected call of GetReplicationTasks.
func (mr *MockExecutionManagerMockRecorder) GetReplicationTasks(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReplicationTasks", reflect.TypeOf((*MockExecutionManager)(nil).GetReplicationTasks), arg0, arg1)
}

// GetReplicationTasksFromDLQ mocks base method.
func (m *MockExecutionManager) GetReplicationTasksFromDLQ(arg0 context.Context, arg1 *GetReplicationTasksFromDLQRequest) (*GetReplicationTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicationTasksFromDLQ", arg0, arg1)
	ret0, _ := ret[0].(*GetReplicationTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReplicationTasksFromDLQ indicates an expected call of GetReplicationTasksFromDLQ.
func (mr *MockExecutionManagerMockRecorder) GetReplicationTasksFromDLQ(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReplicationTasksFromDLQ", reflect.TypeOf((*MockExecutionManager)(nil).GetReplicationTasksFromDLQ), arg0, arg1)
}

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

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

// GetTimerIndexTasks mocks base method.
func (m *MockExecutionManager) GetTimerIndexTasks(arg0 context.Context, arg1 *GetTimerIndexTasksRequest) (*GetTimerIndexTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimerIndexTasks", arg0, arg1)
	ret0, _ := ret[0].(*GetTimerIndexTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTimerIndexTasks indicates an expected call of GetTimerIndexTasks.
func (mr *MockExecutionManagerMockRecorder) GetTimerIndexTasks(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimerIndexTasks", reflect.TypeOf((*MockExecutionManager)(nil).GetTimerIndexTasks), arg0, arg1)
}

// GetTransferTasks mocks base method.
func (m *MockExecutionManager) GetTransferTasks(arg0 context.Context, arg1 *GetTransferTasksRequest) (*GetTransferTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransferTasks", arg0, arg1)
	ret0, _ := ret[0].(*GetTransferTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransferTasks indicates an expected call of GetTransferTasks.
func (mr *MockExecutionManagerMockRecorder) GetTransferTasks(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransferTasks", reflect.TypeOf((*MockExecutionManager)(nil).GetTransferTasks), arg0, arg1)
}

// GetWorkflowExecution mocks base method.
func (m *MockExecutionManager) GetWorkflowExecution(arg0 context.Context, arg1 *GetWorkflowExecutionRequest) (*GetWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflowExecution", arg0, arg1)
	ret0, _ := ret[0].(*GetWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkflowExecution indicates an expected call of GetWorkflowExecution.
func (mr *MockExecutionManagerMockRecorder) GetWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowExecution", reflect.TypeOf((*MockExecutionManager)(nil).GetWorkflowExecution), arg0, arg1)
}

// IsWorkflowExecutionExists mocks base method.
func (m *MockExecutionManager) IsWorkflowExecutionExists(arg0 context.Context, arg1 *IsWorkflowExecutionExistsRequest) (*IsWorkflowExecutionExistsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsWorkflowExecutionExists", arg0, arg1)
	ret0, _ := ret[0].(*IsWorkflowExecutionExistsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsWorkflowExecutionExists indicates an expected call of IsWorkflowExecutionExists.
func (mr *MockExecutionManagerMockRecorder) IsWorkflowExecutionExists(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsWorkflowExecutionExists", reflect.TypeOf((*MockExecutionManager)(nil).IsWorkflowExecutionExists), arg0, arg1)
}

// ListConcreteExecutions mocks base method.
func (m *MockExecutionManager) ListConcreteExecutions(arg0 context.Context, arg1 *ListConcreteExecutionsRequest) (*ListConcreteExecutionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListConcreteExecutions", arg0, arg1)
	ret0, _ := ret[0].(*ListConcreteExecutionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListConcreteExecutions indicates an expected call of ListConcreteExecutions.
func (mr *MockExecutionManagerMockRecorder) ListConcreteExecutions(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConcreteExecutions", reflect.TypeOf((*MockExecutionManager)(nil).ListConcreteExecutions), arg0, arg1)
}

// ListCurrentExecutions mocks base method.
func (m *MockExecutionManager) ListCurrentExecutions(arg0 context.Context, arg1 *ListCurrentExecutionsRequest) (*ListCurrentExecutionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCurrentExecutions", arg0, arg1)
	ret0, _ := ret[0].(*ListCurrentExecutionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCurrentExecutions indicates an expected call of ListCurrentExecutions.
func (mr *MockExecutionManagerMockRecorder) ListCurrentExecutions(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCurrentExecutions", reflect.TypeOf((*MockExecutionManager)(nil).ListCurrentExecutions), arg0, arg1)
}

// PutReplicationTaskToDLQ mocks base method.
func (m *MockExecutionManager) PutReplicationTaskToDLQ(arg0 context.Context, arg1 *PutReplicationTaskToDLQRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutReplicationTaskToDLQ", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// PutReplicationTaskToDLQ indicates an expected call of PutReplicationTaskToDLQ.
func (mr *MockExecutionManagerMockRecorder) PutReplicationTaskToDLQ(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutReplicationTaskToDLQ", reflect.TypeOf((*MockExecutionManager)(nil).PutReplicationTaskToDLQ), arg0, arg1)
}

// RangeCompleteCrossClusterTask mocks base method.
func (m *MockExecutionManager) RangeCompleteCrossClusterTask(arg0 context.Context, arg1 *RangeCompleteCrossClusterTaskRequest) (*RangeCompleteCrossClusterTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeCompleteCrossClusterTask", arg0, arg1)
	ret0, _ := ret[0].(*RangeCompleteCrossClusterTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RangeCompleteCrossClusterTask indicates an expected call of RangeCompleteCrossClusterTask.
func (mr *MockExecutionManagerMockRecorder) RangeCompleteCrossClusterTask(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeCompleteCrossClusterTask", reflect.TypeOf((*MockExecutionManager)(nil).RangeCompleteCrossClusterTask), arg0, arg1)
}

// RangeCompleteReplicationTask mocks base method.
func (m *MockExecutionManager) RangeCompleteReplicationTask(arg0 context.Context, arg1 *RangeCompleteReplicationTaskRequest) (*RangeCompleteReplicationTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeCompleteReplicationTask", arg0, arg1)
	ret0, _ := ret[0].(*RangeCompleteReplicationTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RangeCompleteReplicationTask indicates an expected call of RangeCompleteReplicationTask.
func (mr *MockExecutionManagerMockRecorder) RangeCompleteReplicationTask(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeCompleteReplicationTask", reflect.TypeOf((*MockExecutionManager)(nil).RangeCompleteReplicationTask), arg0, arg1)
}

// RangeCompleteTimerTask mocks base method.
func (m *MockExecutionManager) RangeCompleteTimerTask(arg0 context.Context, arg1 *RangeCompleteTimerTaskRequest) (*RangeCompleteTimerTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeCompleteTimerTask", arg0, arg1)
	ret0, _ := ret[0].(*RangeCompleteTimerTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RangeCompleteTimerTask indicates an expected call of RangeCompleteTimerTask.
func (mr *MockExecutionManagerMockRecorder) RangeCompleteTimerTask(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeCompleteTimerTask", reflect.TypeOf((*MockExecutionManager)(nil).RangeCompleteTimerTask), arg0, arg1)
}

// RangeCompleteTransferTask mocks base method.
func (m *MockExecutionManager) RangeCompleteTransferTask(arg0 context.Context, arg1 *RangeCompleteTransferTaskRequest) (*RangeCompleteTransferTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeCompleteTransferTask", arg0, arg1)
	ret0, _ := ret[0].(*RangeCompleteTransferTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RangeCompleteTransferTask indicates an expected call of RangeCompleteTransferTask.
func (mr *MockExecutionManagerMockRecorder) RangeCompleteTransferTask(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeCompleteTransferTask", reflect.TypeOf((*MockExecutionManager)(nil).RangeCompleteTransferTask), arg0, arg1)
}

// RangeDeleteReplicationTaskFromDLQ mocks base method.
func (m *MockExecutionManager) RangeDeleteReplicationTaskFromDLQ(arg0 context.Context, arg1 *RangeDeleteReplicationTaskFromDLQRequest) (*RangeDeleteReplicationTaskFromDLQResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteReplicationTaskFromDLQ", arg0, arg1)
	ret0, _ := ret[0].(*RangeDeleteReplicationTaskFromDLQResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RangeDeleteReplicationTaskFromDLQ indicates an expected call of RangeDeleteReplicationTaskFromDLQ.
func (mr *MockExecutionManagerMockRecorder) RangeDeleteReplicationTaskFromDLQ(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteReplicationTaskFromDLQ", reflect.TypeOf((*MockExecutionManager)(nil).RangeDeleteReplicationTaskFromDLQ), arg0, arg1)
}

// UpdateWorkflowExecution mocks base method.
func (m *MockExecutionManager) UpdateWorkflowExecution(arg0 context.Context, arg1 *UpdateWorkflowExecutionRequest) (*UpdateWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkflowExecution", arg0, arg1)
	ret0, _ := ret[0].(*UpdateWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateWorkflowExecution indicates an expected call of UpdateWorkflowExecution.
func (mr *MockExecutionManagerMockRecorder) UpdateWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkflowExecution", reflect.TypeOf((*MockExecutionManager)(nil).UpdateWorkflowExecution), arg0, arg1)
}

// MockExecutionManagerFactory is a mock of ExecutionManagerFactory interface.
type MockExecutionManagerFactory struct {
	ctrl     *gomock.Controller
	recorder *MockExecutionManagerFactoryMockRecorder
}

// MockExecutionManagerFactoryMockRecorder is the mock recorder for MockExecutionManagerFactory.
type MockExecutionManagerFactoryMockRecorder struct {
	mock *MockExecutionManagerFactory
}

// NewMockExecutionManagerFactory creates a new mock instance.
func NewMockExecutionManagerFactory(ctrl *gomock.Controller) *MockExecutionManagerFactory {
	mock := &MockExecutionManagerFactory{ctrl: ctrl}
	mock.recorder = &MockExecutionManagerFactoryMockRecorder{mock}
	return mock
}

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

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

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

// NewExecutionManager mocks base method.
func (m *MockExecutionManagerFactory) NewExecutionManager(arg0 int) (ExecutionManager, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewExecutionManager", arg0)
	ret0, _ := ret[0].(ExecutionManager)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewExecutionManager indicates an expected call of NewExecutionManager.
func (mr *MockExecutionManagerFactoryMockRecorder) NewExecutionManager(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewExecutionManager", reflect.TypeOf((*MockExecutionManagerFactory)(nil).NewExecutionManager), arg0)
}

// MockTaskManager is a mock of TaskManager interface.
type MockTaskManager struct {
	ctrl     *gomock.Controller
	recorder *MockTaskManagerMockRecorder
}

// MockTaskManagerMockRecorder is the mock recorder for MockTaskManager.
type MockTaskManagerMockRecorder struct {
	mock *MockTaskManager
}

// NewMockTaskManager creates a new mock instance.
func NewMockTaskManager(ctrl *gomock.Controller) *MockTaskManager {
	mock := &MockTaskManager{ctrl: ctrl}
	mock.recorder = &MockTaskManagerMockRecorder{mock}
	return mock
}

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

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

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

// CompleteTask mocks base method.
func (m *MockTaskManager) CompleteTask(arg0 context.Context, arg1 *CompleteTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteTask", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CompleteTask indicates an expected call of CompleteTask.
func (mr *MockTaskManagerMockRecorder) CompleteTask(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTask", reflect.TypeOf((*MockTaskManager)(nil).CompleteTask), arg0, arg1)
}

// CompleteTasksLessThan mocks base method.
func (m *MockTaskManager) CompleteTasksLessThan(arg0 context.Context, arg1 *CompleteTasksLessThanRequest) (*CompleteTasksLessThanResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteTasksLessThan", arg0, arg1)
	ret0, _ := ret[0].(*CompleteTasksLessThanResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CompleteTasksLessThan indicates an expected call of CompleteTasksLessThan.
func (mr *MockTaskManagerMockRecorder) CompleteTasksLessThan(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTasksLessThan", reflect.TypeOf((*MockTaskManager)(nil).CompleteTasksLessThan), arg0, arg1)
}

// CreateTasks mocks base method.
func (m *MockTaskManager) CreateTasks(arg0 context.Context, arg1 *CreateTasksRequest) (*CreateTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTasks", arg0, arg1)
	ret0, _ := ret[0].(*CreateTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTasks indicates an expected call of CreateTasks.
func (mr *MockTaskManagerMockRecorder) CreateTasks(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTasks", reflect.TypeOf((*MockTaskManager)(nil).CreateTasks), arg0, arg1)
}

// DeleteTaskList mocks base method.
func (m *MockTaskManager) DeleteTaskList(arg0 context.Context, arg1 *DeleteTaskListRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTaskList", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTaskList indicates an expected call of DeleteTaskList.
func (mr *MockTaskManagerMockRecorder) DeleteTaskList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTaskList", reflect.TypeOf((*MockTaskManager)(nil).DeleteTaskList), arg0, arg1)
}

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

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

// GetOrphanTasks mocks base method.
func (m *MockTaskManager) GetOrphanTasks(arg0 context.Context, arg1 *GetOrphanTasksRequest) (*GetOrphanTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrphanTasks", arg0, arg1)
	ret0, _ := ret[0].(*GetOrphanTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrphanTasks indicates an expected call of GetOrphanTasks.
func (mr *MockTaskManagerMockRecorder) GetOrphanTasks(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrphanTasks", reflect.TypeOf((*MockTaskManager)(nil).GetOrphanTasks), arg0, arg1)
}

// GetTaskListSize mocks base method.
func (m *MockTaskManager) GetTaskListSize(arg0 context.Context, arg1 *GetTaskListSizeRequest) (*GetTaskListSizeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTaskListSize", arg0, arg1)
	ret0, _ := ret[0].(*GetTaskListSizeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTaskListSize indicates an expected call of GetTaskListSize.
func (mr *MockTaskManagerMockRecorder) GetTaskListSize(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskListSize", reflect.TypeOf((*MockTaskManager)(nil).GetTaskListSize), arg0, arg1)
}

// GetTasks mocks base method.
func (m *MockTaskManager) GetTasks(arg0 context.Context, arg1 *GetTasksRequest) (*GetTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTasks", arg0, arg1)
	ret0, _ := ret[0].(*GetTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTasks indicates an expected call of GetTasks.
func (mr *MockTaskManagerMockRecorder) GetTasks(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTasks", reflect.TypeOf((*MockTaskManager)(nil).GetTasks), arg0, arg1)
}

// LeaseTaskList mocks base method.
func (m *MockTaskManager) LeaseTaskList(arg0 context.Context, arg1 *LeaseTaskListRequest) (*LeaseTaskListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LeaseTaskList", arg0, arg1)
	ret0, _ := ret[0].(*LeaseTaskListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LeaseTaskList indicates an expected call of LeaseTaskList.
func (mr *MockTaskManagerMockRecorder) LeaseTaskList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LeaseTaskList", reflect.TypeOf((*MockTaskManager)(nil).LeaseTaskList), arg0, arg1)
}

// ListTaskList mocks base method.
func (m *MockTaskManager) ListTaskList(arg0 context.Context, arg1 *ListTaskListRequest) (*ListTaskListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTaskList", arg0, arg1)
	ret0, _ := ret[0].(*ListTaskListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTaskList indicates an expected call of ListTaskList.
func (mr *MockTaskManagerMockRecorder) ListTaskList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskList", reflect.TypeOf((*MockTaskManager)(nil).ListTaskList), arg0, arg1)
}

// UpdateTaskList mocks base method.
func (m *MockTaskManager) UpdateTaskList(arg0 context.Context, arg1 *UpdateTaskListRequest) (*UpdateTaskListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskList", arg0, arg1)
	ret0, _ := ret[0].(*UpdateTaskListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTaskList indicates an expected call of UpdateTaskList.
func (mr *MockTaskManagerMockRecorder) UpdateTaskList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskList", reflect.TypeOf((*MockTaskManager)(nil).UpdateTaskList), arg0, arg1)
}

// MockHistoryManager is a mock of HistoryManager interface.
type MockHistoryManager struct {
	ctrl     *gomock.Controller
	recorder *MockHistoryManagerMockRecorder
}

// MockHistoryManagerMockRecorder is the mock recorder for MockHistoryManager.
type MockHistoryManagerMockRecorder struct {
	mock *MockHistoryManager
}

// NewMockHistoryManager creates a new mock instance.
func NewMockHistoryManager(ctrl *gomock.Controller) *MockHistoryManager {
	mock := &MockHistoryManager{ctrl: ctrl}
	mock.recorder = &MockHistoryManagerMockRecorder{mock}
	return mock
}

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

// AppendHistoryNodes mocks base method.
func (m *MockHistoryManager) AppendHistoryNodes(arg0 context.Context, arg1 *AppendHistoryNodesRequest) (*AppendHistoryNodesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppendHistoryNodes", arg0, arg1)
	ret0, _ := ret[0].(*AppendHistoryNodesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AppendHistoryNodes indicates an expected call of AppendHistoryNodes.
func (mr *MockHistoryManagerMockRecorder) AppendHistoryNodes(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendHistoryNodes", reflect.TypeOf((*MockHistoryManager)(nil).AppendHistoryNodes), arg0, arg1)
}

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

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

// DeleteHistoryBranch mocks base method.
func (m *MockHistoryManager) DeleteHistoryBranch(arg0 context.Context, arg1 *DeleteHistoryBranchRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHistoryBranch", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteHistoryBranch indicates an expected call of DeleteHistoryBranch.
func (mr *MockHistoryManagerMockRecorder) DeleteHistoryBranch(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHistoryBranch", reflect.TypeOf((*MockHistoryManager)(nil).DeleteHistoryBranch), arg0, arg1)
}

// ForkHistoryBranch mocks base method.
func (m *MockHistoryManager) ForkHistoryBranch(arg0 context.Context, arg1 *ForkHistoryBranchRequest) (*ForkHistoryBranchResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForkHistoryBranch", arg0, arg1)
	ret0, _ := ret[0].(*ForkHistoryBranchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ForkHistoryBranch indicates an expected call of ForkHistoryBranch.
func (mr *MockHistoryManagerMockRecorder) ForkHistoryBranch(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForkHistoryBranch", reflect.TypeOf((*MockHistoryManager)(nil).ForkHistoryBranch), arg0, arg1)
}

// GetAllHistoryTreeBranches mocks base method.
func (m *MockHistoryManager) GetAllHistoryTreeBranches(arg0 context.Context, arg1 *GetAllHistoryTreeBranchesRequest) (*GetAllHistoryTreeBranchesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllHistoryTreeBranches", arg0, arg1)
	ret0, _ := ret[0].(*GetAllHistoryTreeBranchesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllHistoryTreeBranches indicates an expected call of GetAllHistoryTreeBranches.
func (mr *MockHistoryManagerMockRecorder) GetAllHistoryTreeBranches(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllHistoryTreeBranches", reflect.TypeOf((*MockHistoryManager)(nil).GetAllHistoryTreeBranches), arg0, arg1)
}

// GetHistoryTree mocks base method.
func (m *MockHistoryManager) GetHistoryTree(arg0 context.Context, arg1 *GetHistoryTreeRequest) (*GetHistoryTreeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHistoryTree", arg0, arg1)
	ret0, _ := ret[0].(*GetHistoryTreeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHistoryTree indicates an expected call of GetHistoryTree.
func (mr *MockHistoryManagerMockRecorder) GetHistoryTree(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoryTree", reflect.TypeOf((*MockHistoryManager)(nil).GetHistoryTree), arg0, arg1)
}

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

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

// ReadHistoryBranch mocks base method.
func (m *MockHistoryManager) ReadHistoryBranch(arg0 context.Context, arg1 *ReadHistoryBranchRequest) (*ReadHistoryBranchResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadHistoryBranch", arg0, arg1)
	ret0, _ := ret[0].(*ReadHistoryBranchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadHistoryBranch indicates an expected call of ReadHistoryBranch.
func (mr *MockHistoryManagerMockRecorder) ReadHistoryBranch(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadHistoryBranch", reflect.TypeOf((*MockHistoryManager)(nil).ReadHistoryBranch), arg0, arg1)
}

// ReadHistoryBranchByBatch mocks base method.
func (m *MockHistoryManager) ReadHistoryBranchByBatch(arg0 context.Context, arg1 *ReadHistoryBranchRequest) (*ReadHistoryBranchByBatchResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadHistoryBranchByBatch", arg0, arg1)
	ret0, _ := ret[0].(*ReadHistoryBranchByBatchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadHistoryBranchByBatch indicates an expected call of ReadHistoryBranchByBatch.
func (mr *MockHistoryManagerMockRecorder) ReadHistoryBranchByBatch(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadHistoryBranchByBatch", reflect.TypeOf((*MockHistoryManager)(nil).ReadHistoryBranchByBatch), arg0, arg1)
}

// ReadRawHistoryBranch mocks base method.
func (m *MockHistoryManager) ReadRawHistoryBranch(arg0 context.Context, arg1 *ReadHistoryBranchRequest) (*ReadRawHistoryBranchResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadRawHistoryBranch", arg0, arg1)
	ret0, _ := ret[0].(*ReadRawHistoryBranchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadRawHistoryBranch indicates an expected call of ReadRawHistoryBranch.
func (mr *MockHistoryManagerMockRecorder) ReadRawHistoryBranch(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadRawHistoryBranch", reflect.TypeOf((*MockHistoryManager)(nil).ReadRawHistoryBranch), arg0, arg1)
}

// MockDomainManager is a mock of DomainManager interface.
type MockDomainManager struct {
	ctrl     *gomock.Controller
	recorder *MockDomainManagerMockRecorder
}

// MockDomainManagerMockRecorder is the mock recorder for MockDomainManager.
type MockDomainManagerMockRecorder struct {
	mock *MockDomainManager
}

// NewMockDomainManager creates a new mock instance.
func NewMockDomainManager(ctrl *gomock.Controller) *MockDomainManager {
	mock := &MockDomainManager{ctrl: ctrl}
	mock.recorder = &MockDomainManagerMockRecorder{mock}
	return mock
}

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

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

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

// CreateDomain mocks base method.
func (m *MockDomainManager) CreateDomain(arg0 context.Context, arg1 *CreateDomainRequest) (*CreateDomainResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDomain", arg0, arg1)
	ret0, _ := ret[0].(*CreateDomainResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDomain indicates an expected call of CreateDomain.
func (mr *MockDomainManagerMockRecorder) CreateDomain(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDomain", reflect.TypeOf((*MockDomainManager)(nil).CreateDomain), arg0, arg1)
}

// DeleteDomain mocks base method.
func (m *MockDomainManager) DeleteDomain(arg0 context.Context, arg1 *DeleteDomainRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDomain", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDomain indicates an expected call of DeleteDomain.
func (mr *MockDomainManagerMockRecorder) DeleteDomain(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDomain", reflect.TypeOf((*MockDomainManager)(nil).DeleteDomain), arg0, arg1)
}

// DeleteDomainByName mocks base method.
func (m *MockDomainManager) DeleteDomainByName(arg0 context.Context, arg1 *DeleteDomainByNameRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDomainByName", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDomainByName indicates an expected call of DeleteDomainByName.
func (mr *MockDomainManagerMockRecorder) DeleteDomainByName(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDomainByName", reflect.TypeOf((*MockDomainManager)(nil).DeleteDomainByName), arg0, arg1)
}

// GetDomain mocks base method.
func (m *MockDomainManager) GetDomain(arg0 context.Context, arg1 *GetDomainRequest) (*GetDomainResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDomain", arg0, arg1)
	ret0, _ := ret[0].(*GetDomainResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDomain indicates an expected call of GetDomain.
func (mr *MockDomainManagerMockRecorder) GetDomain(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDomain", reflect.TypeOf((*MockDomainManager)(nil).GetDomain), arg0, arg1)
}

// GetMetadata mocks base method.
func (m *MockDomainManager) GetMetadata(arg0 context.Context) (*GetMetadataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetadata", arg0)
	ret0, _ := ret[0].(*GetMetadataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMetadata indicates an expected call of GetMetadata.
func (mr *MockDomainManagerMockRecorder) GetMetadata(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockDomainManager)(nil).GetMetadata), arg0)
}

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

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

// ListDomains mocks base method.
func (m *MockDomainManager) ListDomains(arg0 context.Context, arg1 *ListDomainsRequest) (*ListDomainsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDomains", arg0, arg1)
	ret0, _ := ret[0].(*ListDomainsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDomains indicates an expected call of ListDomains.
func (mr *MockDomainManagerMockRecorder) ListDomains(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDomains", reflect.TypeOf((*MockDomainManager)(nil).ListDomains), arg0, arg1)
}

// UpdateDomain mocks base method.
func (m *MockDomainManager) UpdateDomain(arg0 context.Context, arg1 *UpdateDomainRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDomain", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDomain indicates an expected call of UpdateDomain.
func (mr *MockDomainManagerMockRecorder) UpdateDomain(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDomain", reflect.TypeOf((*MockDomainManager)(nil).UpdateDomain), arg0, arg1)
}

// MockQueueManager is a mock of QueueManager interface.
type MockQueueManager struct {
	ctrl     *gomock.Controller
	recorder *MockQueueManagerMockRecorder
}

// MockQueueManagerMockRecorder is the mock recorder for MockQueueManager.
type MockQueueManagerMockRecorder struct {
	mock *MockQueueManager
}

// NewMockQueueManager creates a new mock instance.
func NewMockQueueManager(ctrl *gomock.Controller) *MockQueueManager {
	mock := &MockQueueManager{ctrl: ctrl}
	mock.recorder = &MockQueueManagerMockRecorder{mock}
	return mock
}

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

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

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

// DeleteMessageFromDLQ mocks base method.
func (m *MockQueueManager) DeleteMessageFromDLQ(arg0 context.Context, arg1 int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessageFromDLQ", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMessageFromDLQ indicates an expected call of DeleteMessageFromDLQ.
func (mr *MockQueueManagerMockRecorder) DeleteMessageFromDLQ(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageFromDLQ", reflect.TypeOf((*MockQueueManager)(nil).DeleteMessageFromDLQ), arg0, arg1)
}

// DeleteMessagesBefore mocks base method.
func (m *MockQueueManager) DeleteMessagesBefore(arg0 context.Context, arg1 int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessagesBefore", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMessagesBefore indicates an expected call of DeleteMessagesBefore.
func (mr *MockQueueManagerMockRecorder) DeleteMessagesBefore(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessagesBefore", reflect.TypeOf((*MockQueueManager)(nil).DeleteMessagesBefore), arg0, arg1)
}

// EnqueueMessage mocks base method.
func (m *MockQueueManager) EnqueueMessage(arg0 context.Context, arg1 []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnqueueMessage", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// EnqueueMessage indicates an expected call of EnqueueMessage.
func (mr *MockQueueManagerMockRecorder) EnqueueMessage(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnqueueMessage", reflect.TypeOf((*MockQueueManager)(nil).EnqueueMessage), arg0, arg1)
}

// EnqueueMessageToDLQ mocks base method.
func (m *MockQueueManager) EnqueueMessageToDLQ(arg0 context.Context, arg1 []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnqueueMessageToDLQ", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// EnqueueMessageToDLQ indicates an expected call of EnqueueMessageToDLQ.
func (mr *MockQueueManagerMockRecorder) EnqueueMessageToDLQ(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnqueueMessageToDLQ", reflect.TypeOf((*MockQueueManager)(nil).EnqueueMessageToDLQ), arg0, arg1)
}

// GetAckLevels mocks base method.
func (m *MockQueueManager) GetAckLevels(arg0 context.Context) (map[string]int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAckLevels", arg0)
	ret0, _ := ret[0].(map[string]int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAckLevels indicates an expected call of GetAckLevels.
func (mr *MockQueueManagerMockRecorder) GetAckLevels(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAckLevels", reflect.TypeOf((*MockQueueManager)(nil).GetAckLevels), arg0)
}

// GetDLQAckLevels mocks base method.
func (m *MockQueueManager) GetDLQAckLevels(arg0 context.Context) (map[string]int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDLQAckLevels", arg0)
	ret0, _ := ret[0].(map[string]int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDLQAckLevels indicates an expected call of GetDLQAckLevels.
func (mr *MockQueueManagerMockRecorder) GetDLQAckLevels(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDLQAckLevels", reflect.TypeOf((*MockQueueManager)(nil).GetDLQAckLevels), arg0)
}

// GetDLQSize mocks base method.
func (m *MockQueueManager) GetDLQSize(arg0 context.Context) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDLQSize", arg0)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDLQSize indicates an expected call of GetDLQSize.
func (mr *MockQueueManagerMockRecorder) GetDLQSize(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDLQSize", reflect.TypeOf((*MockQueueManager)(nil).GetDLQSize), arg0)
}

// RangeDeleteMessagesFromDLQ mocks base method.
func (m *MockQueueManager) RangeDeleteMessagesFromDLQ(arg0 context.Context, arg1, arg2 int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteMessagesFromDLQ", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteMessagesFromDLQ indicates an expected call of RangeDeleteMessagesFromDLQ.
func (mr *MockQueueManagerMockRecorder) RangeDeleteMessagesFromDLQ(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteMessagesFromDLQ", reflect.TypeOf((*MockQueueManager)(nil).RangeDeleteMessagesFromDLQ), arg0, arg1, arg2)
}

// ReadMessages mocks base method.
func (m *MockQueueManager) ReadMessages(arg0 context.Context, arg1 int64, arg2 int) (QueueMessageList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadMessages", arg0, arg1, arg2)
	ret0, _ := ret[0].(QueueMessageList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadMessages indicates an expected call of ReadMessages.
func (mr *MockQueueManagerMockRecorder) ReadMessages(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadMessages", reflect.TypeOf((*MockQueueManager)(nil).ReadMessages), arg0, arg1, arg2)
}

// ReadMessagesFromDLQ mocks base method.
func (m *MockQueueManager) ReadMessagesFromDLQ(arg0 context.Context, arg1, arg2 int64, arg3 int, arg4 []byte) ([]*QueueMessage, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadMessagesFromDLQ", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].([]*QueueMessage)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReadMessagesFromDLQ indicates an expected call of ReadMessagesFromDLQ.
func (mr *MockQueueManagerMockRecorder) ReadMessagesFromDLQ(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadMessagesFromDLQ", reflect.TypeOf((*MockQueueManager)(nil).ReadMessagesFromDLQ), arg0, arg1, arg2, arg3, arg4)
}

// UpdateAckLevel mocks base method.
func (m *MockQueueManager) UpdateAckLevel(arg0 context.Context, arg1 int64, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAckLevel", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateAckLevel indicates an expected call of UpdateAckLevel.
func (mr *MockQueueManagerMockRecorder) UpdateAckLevel(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAckLevel", reflect.TypeOf((*MockQueueManager)(nil).UpdateAckLevel), arg0, arg1, arg2)
}

// UpdateDLQAckLevel mocks base method.
func (m *MockQueueManager) UpdateDLQAckLevel(arg0 context.Context, arg1 int64, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDLQAckLevel", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDLQAckLevel indicates an expected call of UpdateDLQAckLevel.
func (mr *MockQueueManagerMockRecorder) UpdateDLQAckLevel(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDLQAckLevel", reflect.TypeOf((*MockQueueManager)(nil).UpdateDLQAckLevel), arg0, arg1, arg2)
}

// MockConfigStoreManager is a mock of ConfigStoreManager interface.
type MockConfigStoreManager struct {
	ctrl     *gomock.Controller
	recorder *MockConfigStoreManagerMockRecorder
}

// MockConfigStoreManagerMockRecorder is the mock recorder for MockConfigStoreManager.
type MockConfigStoreManagerMockRecorder struct {
	mock *MockConfigStoreManager
}

// NewMockConfigStoreManager creates a new mock instance.
func NewMockConfigStoreManager(ctrl *gomock.Controller) *MockConfigStoreManager {
	mock := &MockConfigStoreManager{ctrl: ctrl}
	mock.recorder = &MockConfigStoreManagerMockRecorder{mock}
	return mock
}

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

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

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

// FetchDynamicConfig mocks base method.
func (m *MockConfigStoreManager) FetchDynamicConfig(arg0 context.Context, arg1 ConfigType) (*FetchDynamicConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchDynamicConfig", arg0, arg1)
	ret0, _ := ret[0].(*FetchDynamicConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchDynamicConfig indicates an expected call of FetchDynamicConfig.
func (mr *MockConfigStoreManagerMockRecorder) FetchDynamicConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchDynamicConfig", reflect.TypeOf((*MockConfigStoreManager)(nil).FetchDynamicConfig), arg0, arg1)
}

// UpdateDynamicConfig mocks base method.
func (m *MockConfigStoreManager) UpdateDynamicConfig(arg0 context.Context, arg1 *UpdateDynamicConfigRequest, arg2 ConfigType) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDynamicConfig", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDynamicConfig indicates an expected call of UpdateDynamicConfig.
func (mr *MockConfigStoreManagerMockRecorder) UpdateDynamicConfig(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDynamicConfig", reflect.TypeOf((*MockConfigStoreManager)(nil).UpdateDynamicConfig), arg0, arg1, arg2)
}