common/persistence/nosql/nosqlplugin/interfaces_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: interfaces.go

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

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

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

	config "github.com/uber/cadence/common/config"
	log "github.com/uber/cadence/common/log"
	persistence "github.com/uber/cadence/common/persistence"
)

// MockPlugin is a mock of Plugin interface.
type MockPlugin struct {
	ctrl     *gomock.Controller
	recorder *MockPluginMockRecorder
}

// MockPluginMockRecorder is the mock recorder for MockPlugin.
type MockPluginMockRecorder struct {
	mock *MockPlugin
}

// NewMockPlugin creates a new mock instance.
func NewMockPlugin(ctrl *gomock.Controller) *MockPlugin {
	mock := &MockPlugin{ctrl: ctrl}
	mock.recorder = &MockPluginMockRecorder{mock}
	return mock
}

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

// CreateAdminDB mocks base method.
func (m *MockPlugin) CreateAdminDB(cfg *config.NoSQL, logger log.Logger, dc *persistence.DynamicConfiguration) (AdminDB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAdminDB", cfg, logger, dc)
	ret0, _ := ret[0].(AdminDB)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAdminDB indicates an expected call of CreateAdminDB.
func (mr *MockPluginMockRecorder) CreateAdminDB(cfg, logger, dc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAdminDB", reflect.TypeOf((*MockPlugin)(nil).CreateAdminDB), cfg, logger, dc)
}

// CreateDB mocks base method.
func (m *MockPlugin) CreateDB(cfg *config.NoSQL, logger log.Logger, dc *persistence.DynamicConfiguration) (DB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDB", cfg, logger, dc)
	ret0, _ := ret[0].(DB)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDB indicates an expected call of CreateDB.
func (mr *MockPluginMockRecorder) CreateDB(cfg, logger, dc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDB", reflect.TypeOf((*MockPlugin)(nil).CreateDB), cfg, logger, dc)
}

// MockAdminDB is a mock of AdminDB interface.
type MockAdminDB struct {
	ctrl     *gomock.Controller
	recorder *MockAdminDBMockRecorder
}

// MockAdminDBMockRecorder is the mock recorder for MockAdminDB.
type MockAdminDBMockRecorder struct {
	mock *MockAdminDB
}

// NewMockAdminDB creates a new mock instance.
func NewMockAdminDB(ctrl *gomock.Controller) *MockAdminDB {
	mock := &MockAdminDB{ctrl: ctrl}
	mock.recorder = &MockAdminDBMockRecorder{mock}
	return mock
}

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

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

// SetupTestDatabase indicates an expected call of SetupTestDatabase.
func (mr *MockAdminDBMockRecorder) SetupTestDatabase(schemaBaseDir interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupTestDatabase", reflect.TypeOf((*MockAdminDB)(nil).SetupTestDatabase), schemaBaseDir)
}

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

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

// MockDB is a mock of DB interface.
type MockDB struct {
	ctrl     *gomock.Controller
	recorder *MockDBMockRecorder
}

// MockDBMockRecorder is the mock recorder for MockDB.
type MockDBMockRecorder struct {
	mock *MockDB
}

// NewMockDB creates a new mock instance.
func NewMockDB(ctrl *gomock.Controller) *MockDB {
	mock := &MockDB{ctrl: ctrl}
	mock.recorder = &MockDBMockRecorder{mock}
	return mock
}

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

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

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

// DeleteCrossClusterTask mocks base method.
func (m *MockDB) DeleteCrossClusterTask(ctx context.Context, shardID int, targetCluster string, taskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCrossClusterTask", ctx, shardID, targetCluster, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCrossClusterTask indicates an expected call of DeleteCrossClusterTask.
func (mr *MockDBMockRecorder) DeleteCrossClusterTask(ctx, shardID, targetCluster, taskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCrossClusterTask", reflect.TypeOf((*MockDB)(nil).DeleteCrossClusterTask), ctx, shardID, targetCluster, taskID)
}

// DeleteCurrentWorkflow mocks base method.
func (m *MockDB) DeleteCurrentWorkflow(ctx context.Context, shardID int, domainID, workflowID, currentRunIDCondition string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCurrentWorkflow", ctx, shardID, domainID, workflowID, currentRunIDCondition)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCurrentWorkflow indicates an expected call of DeleteCurrentWorkflow.
func (mr *MockDBMockRecorder) DeleteCurrentWorkflow(ctx, shardID, domainID, workflowID, currentRunIDCondition interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCurrentWorkflow", reflect.TypeOf((*MockDB)(nil).DeleteCurrentWorkflow), ctx, shardID, domainID, workflowID, currentRunIDCondition)
}

// DeleteDomain mocks base method.
func (m *MockDB) DeleteDomain(ctx context.Context, domainID, domainName *string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDomain", ctx, domainID, domainName)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDomain indicates an expected call of DeleteDomain.
func (mr *MockDBMockRecorder) DeleteDomain(ctx, domainID, domainName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDomain", reflect.TypeOf((*MockDB)(nil).DeleteDomain), ctx, domainID, domainName)
}

// DeleteFromHistoryTreeAndNode mocks base method.
func (m *MockDB) DeleteFromHistoryTreeAndNode(ctx context.Context, treeFilter *HistoryTreeFilter, nodeFilters []*HistoryNodeFilter) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromHistoryTreeAndNode", ctx, treeFilter, nodeFilters)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteFromHistoryTreeAndNode indicates an expected call of DeleteFromHistoryTreeAndNode.
func (mr *MockDBMockRecorder) DeleteFromHistoryTreeAndNode(ctx, treeFilter, nodeFilters interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFromHistoryTreeAndNode", reflect.TypeOf((*MockDB)(nil).DeleteFromHistoryTreeAndNode), ctx, treeFilter, nodeFilters)
}

// DeleteMessage mocks base method.
func (m *MockDB) DeleteMessage(ctx context.Context, queueType persistence.QueueType, messageID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessage", ctx, queueType, messageID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMessage indicates an expected call of DeleteMessage.
func (mr *MockDBMockRecorder) DeleteMessage(ctx, queueType, messageID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessage", reflect.TypeOf((*MockDB)(nil).DeleteMessage), ctx, queueType, messageID)
}

// DeleteMessagesBefore mocks base method.
func (m *MockDB) DeleteMessagesBefore(ctx context.Context, queueType persistence.QueueType, exclusiveBeginMessageID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessagesBefore", ctx, queueType, exclusiveBeginMessageID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMessagesBefore indicates an expected call of DeleteMessagesBefore.
func (mr *MockDBMockRecorder) DeleteMessagesBefore(ctx, queueType, exclusiveBeginMessageID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessagesBefore", reflect.TypeOf((*MockDB)(nil).DeleteMessagesBefore), ctx, queueType, exclusiveBeginMessageID)
}

// DeleteMessagesInRange mocks base method.
func (m *MockDB) DeleteMessagesInRange(ctx context.Context, queueType persistence.QueueType, exclusiveBeginMessageID, inclusiveEndMessageID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessagesInRange", ctx, queueType, exclusiveBeginMessageID, inclusiveEndMessageID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMessagesInRange indicates an expected call of DeleteMessagesInRange.
func (mr *MockDBMockRecorder) DeleteMessagesInRange(ctx, queueType, exclusiveBeginMessageID, inclusiveEndMessageID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessagesInRange", reflect.TypeOf((*MockDB)(nil).DeleteMessagesInRange), ctx, queueType, exclusiveBeginMessageID, inclusiveEndMessageID)
}

// DeleteReplicationDLQTask mocks base method.
func (m *MockDB) DeleteReplicationDLQTask(ctx context.Context, shardID int, sourceCluster string, taskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReplicationDLQTask", ctx, shardID, sourceCluster, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteReplicationDLQTask indicates an expected call of DeleteReplicationDLQTask.
func (mr *MockDBMockRecorder) DeleteReplicationDLQTask(ctx, shardID, sourceCluster, taskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationDLQTask", reflect.TypeOf((*MockDB)(nil).DeleteReplicationDLQTask), ctx, shardID, sourceCluster, taskID)
}

// DeleteReplicationTask mocks base method.
func (m *MockDB) DeleteReplicationTask(ctx context.Context, shardID int, taskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReplicationTask", ctx, shardID, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteReplicationTask indicates an expected call of DeleteReplicationTask.
func (mr *MockDBMockRecorder) DeleteReplicationTask(ctx, shardID, taskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationTask", reflect.TypeOf((*MockDB)(nil).DeleteReplicationTask), ctx, shardID, taskID)
}

// DeleteTaskList mocks base method.
func (m *MockDB) DeleteTaskList(ctx context.Context, filter *TaskListFilter, previousRangeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTaskList", ctx, filter, previousRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTaskList indicates an expected call of DeleteTaskList.
func (mr *MockDBMockRecorder) DeleteTaskList(ctx, filter, previousRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTaskList", reflect.TypeOf((*MockDB)(nil).DeleteTaskList), ctx, filter, previousRangeID)
}

// DeleteTimerTask mocks base method.
func (m *MockDB) DeleteTimerTask(ctx context.Context, shardID int, taskID int64, visibilityTimestamp time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTimerTask", ctx, shardID, taskID, visibilityTimestamp)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTimerTask indicates an expected call of DeleteTimerTask.
func (mr *MockDBMockRecorder) DeleteTimerTask(ctx, shardID, taskID, visibilityTimestamp interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTimerTask", reflect.TypeOf((*MockDB)(nil).DeleteTimerTask), ctx, shardID, taskID, visibilityTimestamp)
}

// DeleteTransferTask mocks base method.
func (m *MockDB) DeleteTransferTask(ctx context.Context, shardID int, taskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransferTask", ctx, shardID, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTransferTask indicates an expected call of DeleteTransferTask.
func (mr *MockDBMockRecorder) DeleteTransferTask(ctx, shardID, taskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransferTask", reflect.TypeOf((*MockDB)(nil).DeleteTransferTask), ctx, shardID, taskID)
}

// DeleteVisibility mocks base method.
func (m *MockDB) DeleteVisibility(ctx context.Context, domainID, workflowID, runID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVisibility", ctx, domainID, workflowID, runID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteVisibility indicates an expected call of DeleteVisibility.
func (mr *MockDBMockRecorder) DeleteVisibility(ctx, domainID, workflowID, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVisibility", reflect.TypeOf((*MockDB)(nil).DeleteVisibility), ctx, domainID, workflowID, runID)
}

// DeleteWorkflowExecution mocks base method.
func (m *MockDB) DeleteWorkflowExecution(ctx context.Context, shardID int, domainID, workflowID, runID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkflowExecution", ctx, shardID, domainID, workflowID, runID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteWorkflowExecution indicates an expected call of DeleteWorkflowExecution.
func (mr *MockDBMockRecorder) DeleteWorkflowExecution(ctx, shardID, domainID, workflowID, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkflowExecution", reflect.TypeOf((*MockDB)(nil).DeleteWorkflowExecution), ctx, shardID, domainID, workflowID, runID)
}

// GetQueueSize mocks base method.
func (m *MockDB) GetQueueSize(ctx context.Context, queueType persistence.QueueType) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueueSize", ctx, queueType)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// InsertConfig mocks base method.
func (m *MockDB) InsertConfig(ctx context.Context, row *persistence.InternalConfigStoreEntry) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertConfig", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertDomain mocks base method.
func (m *MockDB) InsertDomain(ctx context.Context, row *DomainRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertDomain", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertIntoHistoryTreeAndNode mocks base method.
func (m *MockDB) InsertIntoHistoryTreeAndNode(ctx context.Context, treeRow *HistoryTreeRow, nodeRow *HistoryNodeRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoHistoryTreeAndNode", ctx, treeRow, nodeRow)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertIntoHistoryTreeAndNode indicates an expected call of InsertIntoHistoryTreeAndNode.
func (mr *MockDBMockRecorder) InsertIntoHistoryTreeAndNode(ctx, treeRow, nodeRow interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertIntoHistoryTreeAndNode", reflect.TypeOf((*MockDB)(nil).InsertIntoHistoryTreeAndNode), ctx, treeRow, nodeRow)
}

// InsertIntoQueue mocks base method.
func (m *MockDB) InsertIntoQueue(ctx context.Context, row *QueueMessageRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoQueue", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertQueueMetadata mocks base method.
func (m *MockDB) InsertQueueMetadata(ctx context.Context, queueType persistence.QueueType, version int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertQueueMetadata", ctx, queueType, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertQueueMetadata indicates an expected call of InsertQueueMetadata.
func (mr *MockDBMockRecorder) InsertQueueMetadata(ctx, queueType, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertQueueMetadata", reflect.TypeOf((*MockDB)(nil).InsertQueueMetadata), ctx, queueType, version)
}

// InsertReplicationDLQTask mocks base method.
func (m *MockDB) InsertReplicationDLQTask(ctx context.Context, shardID int, sourceCluster string, task ReplicationTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertReplicationDLQTask", ctx, shardID, sourceCluster, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertReplicationDLQTask indicates an expected call of InsertReplicationDLQTask.
func (mr *MockDBMockRecorder) InsertReplicationDLQTask(ctx, shardID, sourceCluster, task interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertReplicationDLQTask", reflect.TypeOf((*MockDB)(nil).InsertReplicationDLQTask), ctx, shardID, sourceCluster, task)
}

// InsertReplicationTask mocks base method.
func (m *MockDB) InsertReplicationTask(ctx context.Context, tasks []*ReplicationTask, condition ShardCondition) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertReplicationTask", ctx, tasks, condition)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertReplicationTask indicates an expected call of InsertReplicationTask.
func (mr *MockDBMockRecorder) InsertReplicationTask(ctx, tasks, condition interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertReplicationTask", reflect.TypeOf((*MockDB)(nil).InsertReplicationTask), ctx, tasks, condition)
}

// InsertShard mocks base method.
func (m *MockDB) InsertShard(ctx context.Context, row *ShardRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertShard", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertTaskList mocks base method.
func (m *MockDB) InsertTaskList(ctx context.Context, row *TaskListRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTaskList", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertTasks mocks base method.
func (m *MockDB) InsertTasks(ctx context.Context, tasksToInsert []*TaskRowForInsert, tasklistCondition *TaskListRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTasks", ctx, tasksToInsert, tasklistCondition)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertTasks indicates an expected call of InsertTasks.
func (mr *MockDBMockRecorder) InsertTasks(ctx, tasksToInsert, tasklistCondition interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertTasks", reflect.TypeOf((*MockDB)(nil).InsertTasks), ctx, tasksToInsert, tasklistCondition)
}

// InsertVisibility mocks base method.
func (m *MockDB) InsertVisibility(ctx context.Context, ttlSeconds int64, row *VisibilityRowForInsert) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertVisibility", ctx, ttlSeconds, row)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertVisibility indicates an expected call of InsertVisibility.
func (mr *MockDBMockRecorder) InsertVisibility(ctx, ttlSeconds, row interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertVisibility", reflect.TypeOf((*MockDB)(nil).InsertVisibility), ctx, ttlSeconds, row)
}

// InsertWorkflowExecutionWithTasks mocks base method.
func (m *MockDB) InsertWorkflowExecutionWithTasks(ctx context.Context, currentWorkflowRequest *CurrentWorkflowWriteRequest, execution *WorkflowExecutionRequest, transferTasks []*TransferTask, crossClusterTasks []*CrossClusterTask, replicationTasks []*ReplicationTask, timerTasks []*TimerTask, shardCondition *ShardCondition) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkflowExecutionWithTasks", ctx, currentWorkflowRequest, execution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertWorkflowExecutionWithTasks indicates an expected call of InsertWorkflowExecutionWithTasks.
func (mr *MockDBMockRecorder) InsertWorkflowExecutionWithTasks(ctx, currentWorkflowRequest, execution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkflowExecutionWithTasks", reflect.TypeOf((*MockDB)(nil).InsertWorkflowExecutionWithTasks), ctx, currentWorkflowRequest, execution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition)
}

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

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

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

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

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

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

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

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

// IsWorkflowExecutionExists mocks base method.
func (m *MockDB) IsWorkflowExecutionExists(ctx context.Context, shardID int, domainID, workflowID, runID string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsWorkflowExecutionExists", ctx, shardID, domainID, workflowID, runID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsWorkflowExecutionExists indicates an expected call of IsWorkflowExecutionExists.
func (mr *MockDBMockRecorder) IsWorkflowExecutionExists(ctx, shardID, domainID, workflowID, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsWorkflowExecutionExists", reflect.TypeOf((*MockDB)(nil).IsWorkflowExecutionExists), ctx, shardID, domainID, workflowID, runID)
}

// ListTaskList mocks base method.
func (m *MockDB) ListTaskList(ctx context.Context, pageSize int, nextPageToken []byte) (*ListTaskListResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTaskList", ctx, pageSize, nextPageToken)
	ret0, _ := ret[0].(*ListTaskListResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTaskList indicates an expected call of ListTaskList.
func (mr *MockDBMockRecorder) ListTaskList(ctx, pageSize, nextPageToken interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskList", reflect.TypeOf((*MockDB)(nil).ListTaskList), ctx, pageSize, nextPageToken)
}

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

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

// RangeDeleteCrossClusterTasks mocks base method.
func (m *MockDB) RangeDeleteCrossClusterTasks(ctx context.Context, shardID int, targetCluster string, exclusiveBeginTaskID, inclusiveEndTaskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteCrossClusterTasks", ctx, shardID, targetCluster, exclusiveBeginTaskID, inclusiveEndTaskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteCrossClusterTasks indicates an expected call of RangeDeleteCrossClusterTasks.
func (mr *MockDBMockRecorder) RangeDeleteCrossClusterTasks(ctx, shardID, targetCluster, exclusiveBeginTaskID, inclusiveEndTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteCrossClusterTasks", reflect.TypeOf((*MockDB)(nil).RangeDeleteCrossClusterTasks), ctx, shardID, targetCluster, exclusiveBeginTaskID, inclusiveEndTaskID)
}

// RangeDeleteReplicationDLQTasks mocks base method.
func (m *MockDB) RangeDeleteReplicationDLQTasks(ctx context.Context, shardID int, sourceCluster string, exclusiveBeginTaskID, inclusiveEndTaskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteReplicationDLQTasks", ctx, shardID, sourceCluster, exclusiveBeginTaskID, inclusiveEndTaskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteReplicationDLQTasks indicates an expected call of RangeDeleteReplicationDLQTasks.
func (mr *MockDBMockRecorder) RangeDeleteReplicationDLQTasks(ctx, shardID, sourceCluster, exclusiveBeginTaskID, inclusiveEndTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteReplicationDLQTasks", reflect.TypeOf((*MockDB)(nil).RangeDeleteReplicationDLQTasks), ctx, shardID, sourceCluster, exclusiveBeginTaskID, inclusiveEndTaskID)
}

// RangeDeleteReplicationTasks mocks base method.
func (m *MockDB) RangeDeleteReplicationTasks(ctx context.Context, shardID int, inclusiveEndTaskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteReplicationTasks", ctx, shardID, inclusiveEndTaskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteReplicationTasks indicates an expected call of RangeDeleteReplicationTasks.
func (mr *MockDBMockRecorder) RangeDeleteReplicationTasks(ctx, shardID, inclusiveEndTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteReplicationTasks", reflect.TypeOf((*MockDB)(nil).RangeDeleteReplicationTasks), ctx, shardID, inclusiveEndTaskID)
}

// RangeDeleteTasks mocks base method.
func (m *MockDB) RangeDeleteTasks(ctx context.Context, filter *TasksFilter) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteTasks", ctx, filter)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RangeDeleteTimerTasks mocks base method.
func (m *MockDB) RangeDeleteTimerTasks(ctx context.Context, shardID int, inclusiveMinTime, exclusiveMaxTime time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteTimerTasks", ctx, shardID, inclusiveMinTime, exclusiveMaxTime)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteTimerTasks indicates an expected call of RangeDeleteTimerTasks.
func (mr *MockDBMockRecorder) RangeDeleteTimerTasks(ctx, shardID, inclusiveMinTime, exclusiveMaxTime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteTimerTasks", reflect.TypeOf((*MockDB)(nil).RangeDeleteTimerTasks), ctx, shardID, inclusiveMinTime, exclusiveMaxTime)
}

// RangeDeleteTransferTasks mocks base method.
func (m *MockDB) RangeDeleteTransferTasks(ctx context.Context, shardID int, exclusiveBeginTaskID, inclusiveEndTaskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteTransferTasks", ctx, shardID, exclusiveBeginTaskID, inclusiveEndTaskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteTransferTasks indicates an expected call of RangeDeleteTransferTasks.
func (mr *MockDBMockRecorder) RangeDeleteTransferTasks(ctx, shardID, exclusiveBeginTaskID, inclusiveEndTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteTransferTasks", reflect.TypeOf((*MockDB)(nil).RangeDeleteTransferTasks), ctx, shardID, exclusiveBeginTaskID, inclusiveEndTaskID)
}

// SelectAllCurrentWorkflows mocks base method.
func (m *MockDB) SelectAllCurrentWorkflows(ctx context.Context, shardID int, pageToken []byte, pageSize int) ([]*persistence.CurrentWorkflowExecution, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectAllCurrentWorkflows", ctx, shardID, pageToken, pageSize)
	ret0, _ := ret[0].([]*persistence.CurrentWorkflowExecution)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectAllCurrentWorkflows indicates an expected call of SelectAllCurrentWorkflows.
func (mr *MockDBMockRecorder) SelectAllCurrentWorkflows(ctx, shardID, pageToken, pageSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAllCurrentWorkflows", reflect.TypeOf((*MockDB)(nil).SelectAllCurrentWorkflows), ctx, shardID, pageToken, pageSize)
}

// SelectAllDomains mocks base method.
func (m *MockDB) SelectAllDomains(ctx context.Context, pageSize int, pageToken []byte) ([]*DomainRow, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectAllDomains", ctx, pageSize, pageToken)
	ret0, _ := ret[0].([]*DomainRow)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectAllDomains indicates an expected call of SelectAllDomains.
func (mr *MockDBMockRecorder) SelectAllDomains(ctx, pageSize, pageToken interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAllDomains", reflect.TypeOf((*MockDB)(nil).SelectAllDomains), ctx, pageSize, pageToken)
}

// SelectAllHistoryTrees mocks base method.
func (m *MockDB) SelectAllHistoryTrees(ctx context.Context, nextPageToken []byte, pageSize int) ([]*HistoryTreeRow, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectAllHistoryTrees", ctx, nextPageToken, pageSize)
	ret0, _ := ret[0].([]*HistoryTreeRow)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectAllHistoryTrees indicates an expected call of SelectAllHistoryTrees.
func (mr *MockDBMockRecorder) SelectAllHistoryTrees(ctx, nextPageToken, pageSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAllHistoryTrees", reflect.TypeOf((*MockDB)(nil).SelectAllHistoryTrees), ctx, nextPageToken, pageSize)
}

// SelectAllWorkflowExecutions mocks base method.
func (m *MockDB) SelectAllWorkflowExecutions(ctx context.Context, shardID int, pageToken []byte, pageSize int) ([]*persistence.InternalListConcreteExecutionsEntity, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectAllWorkflowExecutions", ctx, shardID, pageToken, pageSize)
	ret0, _ := ret[0].([]*persistence.InternalListConcreteExecutionsEntity)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectAllWorkflowExecutions indicates an expected call of SelectAllWorkflowExecutions.
func (mr *MockDBMockRecorder) SelectAllWorkflowExecutions(ctx, shardID, pageToken, pageSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAllWorkflowExecutions", reflect.TypeOf((*MockDB)(nil).SelectAllWorkflowExecutions), ctx, shardID, pageToken, pageSize)
}

// SelectCrossClusterTasksOrderByTaskID mocks base method.
func (m *MockDB) SelectCrossClusterTasksOrderByTaskID(ctx context.Context, shardID, pageSize int, pageToken []byte, targetCluster string, exclusiveMinTaskID, inclusiveMaxTaskID int64) ([]*CrossClusterTask, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectCrossClusterTasksOrderByTaskID", ctx, shardID, pageSize, pageToken, targetCluster, exclusiveMinTaskID, inclusiveMaxTaskID)
	ret0, _ := ret[0].([]*CrossClusterTask)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectCrossClusterTasksOrderByTaskID indicates an expected call of SelectCrossClusterTasksOrderByTaskID.
func (mr *MockDBMockRecorder) SelectCrossClusterTasksOrderByTaskID(ctx, shardID, pageSize, pageToken, targetCluster, exclusiveMinTaskID, inclusiveMaxTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectCrossClusterTasksOrderByTaskID", reflect.TypeOf((*MockDB)(nil).SelectCrossClusterTasksOrderByTaskID), ctx, shardID, pageSize, pageToken, targetCluster, exclusiveMinTaskID, inclusiveMaxTaskID)
}

// SelectCurrentWorkflow mocks base method.
func (m *MockDB) SelectCurrentWorkflow(ctx context.Context, shardID int, domainID, workflowID string) (*CurrentWorkflowRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectCurrentWorkflow", ctx, shardID, domainID, workflowID)
	ret0, _ := ret[0].(*CurrentWorkflowRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectCurrentWorkflow indicates an expected call of SelectCurrentWorkflow.
func (mr *MockDBMockRecorder) SelectCurrentWorkflow(ctx, shardID, domainID, workflowID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectCurrentWorkflow", reflect.TypeOf((*MockDB)(nil).SelectCurrentWorkflow), ctx, shardID, domainID, workflowID)
}

// SelectDomain mocks base method.
func (m *MockDB) SelectDomain(ctx context.Context, domainID, domainName *string) (*DomainRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectDomain", ctx, domainID, domainName)
	ret0, _ := ret[0].(*DomainRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectDomain indicates an expected call of SelectDomain.
func (mr *MockDBMockRecorder) SelectDomain(ctx, domainID, domainName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectDomain", reflect.TypeOf((*MockDB)(nil).SelectDomain), ctx, domainID, domainName)
}

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

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

// SelectFromHistoryNode mocks base method.
func (m *MockDB) SelectFromHistoryNode(ctx context.Context, filter *HistoryNodeFilter) ([]*HistoryNodeRow, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectFromHistoryNode", ctx, filter)
	ret0, _ := ret[0].([]*HistoryNodeRow)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// SelectFromHistoryTree mocks base method.
func (m *MockDB) SelectFromHistoryTree(ctx context.Context, filter *HistoryTreeFilter) ([]*HistoryTreeRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectFromHistoryTree", ctx, filter)
	ret0, _ := ret[0].([]*HistoryTreeRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectLastEnqueuedMessageID mocks base method.
func (m *MockDB) SelectLastEnqueuedMessageID(ctx context.Context, queueType persistence.QueueType) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectLastEnqueuedMessageID", ctx, queueType)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectLatestConfig mocks base method.
func (m *MockDB) SelectLatestConfig(ctx context.Context, rowType int) (*persistence.InternalConfigStoreEntry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectLatestConfig", ctx, rowType)
	ret0, _ := ret[0].(*persistence.InternalConfigStoreEntry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectMessagesBetween mocks base method.
func (m *MockDB) SelectMessagesBetween(ctx context.Context, request SelectMessagesBetweenRequest) (*SelectMessagesBetweenResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectMessagesBetween", ctx, request)
	ret0, _ := ret[0].(*SelectMessagesBetweenResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectMessagesFrom mocks base method.
func (m *MockDB) SelectMessagesFrom(ctx context.Context, queueType persistence.QueueType, exclusiveBeginMessageID int64, maxRows int) ([]*QueueMessageRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectMessagesFrom", ctx, queueType, exclusiveBeginMessageID, maxRows)
	ret0, _ := ret[0].([]*QueueMessageRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectMessagesFrom indicates an expected call of SelectMessagesFrom.
func (mr *MockDBMockRecorder) SelectMessagesFrom(ctx, queueType, exclusiveBeginMessageID, maxRows interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectMessagesFrom", reflect.TypeOf((*MockDB)(nil).SelectMessagesFrom), ctx, queueType, exclusiveBeginMessageID, maxRows)
}

// SelectOneClosedWorkflow mocks base method.
func (m *MockDB) SelectOneClosedWorkflow(ctx context.Context, domainID, workflowID, runID string) (*VisibilityRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectOneClosedWorkflow", ctx, domainID, workflowID, runID)
	ret0, _ := ret[0].(*VisibilityRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectOneClosedWorkflow indicates an expected call of SelectOneClosedWorkflow.
func (mr *MockDBMockRecorder) SelectOneClosedWorkflow(ctx, domainID, workflowID, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectOneClosedWorkflow", reflect.TypeOf((*MockDB)(nil).SelectOneClosedWorkflow), ctx, domainID, workflowID, runID)
}

// SelectQueueMetadata mocks base method.
func (m *MockDB) SelectQueueMetadata(ctx context.Context, queueType persistence.QueueType) (*QueueMetadataRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectQueueMetadata", ctx, queueType)
	ret0, _ := ret[0].(*QueueMetadataRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectReplicationDLQTasksCount mocks base method.
func (m *MockDB) SelectReplicationDLQTasksCount(ctx context.Context, shardID int, sourceCluster string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectReplicationDLQTasksCount", ctx, shardID, sourceCluster)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectReplicationDLQTasksCount indicates an expected call of SelectReplicationDLQTasksCount.
func (mr *MockDBMockRecorder) SelectReplicationDLQTasksCount(ctx, shardID, sourceCluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectReplicationDLQTasksCount", reflect.TypeOf((*MockDB)(nil).SelectReplicationDLQTasksCount), ctx, shardID, sourceCluster)
}

// SelectReplicationDLQTasksOrderByTaskID mocks base method.
func (m *MockDB) SelectReplicationDLQTasksOrderByTaskID(ctx context.Context, shardID int, sourceCluster string, pageSize int, pageToken []byte, exclusiveMinTaskID, inclusiveMaxTaskID int64) ([]*ReplicationTask, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectReplicationDLQTasksOrderByTaskID", ctx, shardID, sourceCluster, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
	ret0, _ := ret[0].([]*ReplicationTask)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectReplicationDLQTasksOrderByTaskID indicates an expected call of SelectReplicationDLQTasksOrderByTaskID.
func (mr *MockDBMockRecorder) SelectReplicationDLQTasksOrderByTaskID(ctx, shardID, sourceCluster, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectReplicationDLQTasksOrderByTaskID", reflect.TypeOf((*MockDB)(nil).SelectReplicationDLQTasksOrderByTaskID), ctx, shardID, sourceCluster, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
}

// SelectReplicationTasksOrderByTaskID mocks base method.
func (m *MockDB) SelectReplicationTasksOrderByTaskID(ctx context.Context, shardID, pageSize int, pageToken []byte, exclusiveMinTaskID, inclusiveMaxTaskID int64) ([]*ReplicationTask, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectReplicationTasksOrderByTaskID", ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
	ret0, _ := ret[0].([]*ReplicationTask)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectReplicationTasksOrderByTaskID indicates an expected call of SelectReplicationTasksOrderByTaskID.
func (mr *MockDBMockRecorder) SelectReplicationTasksOrderByTaskID(ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectReplicationTasksOrderByTaskID", reflect.TypeOf((*MockDB)(nil).SelectReplicationTasksOrderByTaskID), ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
}

// SelectShard mocks base method.
func (m *MockDB) SelectShard(ctx context.Context, shardID int, currentClusterName string) (int64, *ShardRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectShard", ctx, shardID, currentClusterName)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(*ShardRow)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectShard indicates an expected call of SelectShard.
func (mr *MockDBMockRecorder) SelectShard(ctx, shardID, currentClusterName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectShard", reflect.TypeOf((*MockDB)(nil).SelectShard), ctx, shardID, currentClusterName)
}

// SelectTaskList mocks base method.
func (m *MockDB) SelectTaskList(ctx context.Context, filter *TaskListFilter) (*TaskListRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectTaskList", ctx, filter)
	ret0, _ := ret[0].(*TaskListRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectTasks mocks base method.
func (m *MockDB) SelectTasks(ctx context.Context, filter *TasksFilter) ([]*TaskRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectTasks", ctx, filter)
	ret0, _ := ret[0].([]*TaskRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectTimerTasksOrderByVisibilityTime mocks base method.
func (m *MockDB) SelectTimerTasksOrderByVisibilityTime(ctx context.Context, shardID, pageSize int, pageToken []byte, inclusiveMinTime, exclusiveMaxTime time.Time) ([]*TimerTask, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectTimerTasksOrderByVisibilityTime", ctx, shardID, pageSize, pageToken, inclusiveMinTime, exclusiveMaxTime)
	ret0, _ := ret[0].([]*TimerTask)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectTimerTasksOrderByVisibilityTime indicates an expected call of SelectTimerTasksOrderByVisibilityTime.
func (mr *MockDBMockRecorder) SelectTimerTasksOrderByVisibilityTime(ctx, shardID, pageSize, pageToken, inclusiveMinTime, exclusiveMaxTime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectTimerTasksOrderByVisibilityTime", reflect.TypeOf((*MockDB)(nil).SelectTimerTasksOrderByVisibilityTime), ctx, shardID, pageSize, pageToken, inclusiveMinTime, exclusiveMaxTime)
}

// SelectTransferTasksOrderByTaskID mocks base method.
func (m *MockDB) SelectTransferTasksOrderByTaskID(ctx context.Context, shardID, pageSize int, pageToken []byte, exclusiveMinTaskID, inclusiveMaxTaskID int64) ([]*TransferTask, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectTransferTasksOrderByTaskID", ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
	ret0, _ := ret[0].([]*TransferTask)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectTransferTasksOrderByTaskID indicates an expected call of SelectTransferTasksOrderByTaskID.
func (mr *MockDBMockRecorder) SelectTransferTasksOrderByTaskID(ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectTransferTasksOrderByTaskID", reflect.TypeOf((*MockDB)(nil).SelectTransferTasksOrderByTaskID), ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
}

// SelectVisibility mocks base method.
func (m *MockDB) SelectVisibility(ctx context.Context, filter *VisibilityFilter) (*SelectVisibilityResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectVisibility", ctx, filter)
	ret0, _ := ret[0].(*SelectVisibilityResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectWorkflowExecution mocks base method.
func (m *MockDB) SelectWorkflowExecution(ctx context.Context, shardID int, domainID, workflowID, runID string) (*WorkflowExecution, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectWorkflowExecution", ctx, shardID, domainID, workflowID, runID)
	ret0, _ := ret[0].(*WorkflowExecution)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectWorkflowExecution indicates an expected call of SelectWorkflowExecution.
func (mr *MockDBMockRecorder) SelectWorkflowExecution(ctx, shardID, domainID, workflowID, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectWorkflowExecution", reflect.TypeOf((*MockDB)(nil).SelectWorkflowExecution), ctx, shardID, domainID, workflowID, runID)
}

// UpdateDomain mocks base method.
func (m *MockDB) UpdateDomain(ctx context.Context, row *DomainRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDomain", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateQueueMetadataCas mocks base method.
func (m *MockDB) UpdateQueueMetadataCas(ctx context.Context, row QueueMetadataRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateQueueMetadataCas", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateRangeID mocks base method.
func (m *MockDB) UpdateRangeID(ctx context.Context, shardID int, rangeID, previousRangeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRangeID", ctx, shardID, rangeID, previousRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateRangeID indicates an expected call of UpdateRangeID.
func (mr *MockDBMockRecorder) UpdateRangeID(ctx, shardID, rangeID, previousRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRangeID", reflect.TypeOf((*MockDB)(nil).UpdateRangeID), ctx, shardID, rangeID, previousRangeID)
}

// UpdateShard mocks base method.
func (m *MockDB) UpdateShard(ctx context.Context, row *ShardRow, previousRangeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateShard", ctx, row, previousRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateShard indicates an expected call of UpdateShard.
func (mr *MockDBMockRecorder) UpdateShard(ctx, row, previousRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateShard", reflect.TypeOf((*MockDB)(nil).UpdateShard), ctx, row, previousRangeID)
}

// UpdateTaskList mocks base method.
func (m *MockDB) UpdateTaskList(ctx context.Context, row *TaskListRow, previousRangeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskList", ctx, row, previousRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTaskList indicates an expected call of UpdateTaskList.
func (mr *MockDBMockRecorder) UpdateTaskList(ctx, row, previousRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskList", reflect.TypeOf((*MockDB)(nil).UpdateTaskList), ctx, row, previousRangeID)
}

// UpdateTaskListWithTTL mocks base method.
func (m *MockDB) UpdateTaskListWithTTL(ctx context.Context, ttlSeconds int64, row *TaskListRow, previousRangeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskListWithTTL", ctx, ttlSeconds, row, previousRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTaskListWithTTL indicates an expected call of UpdateTaskListWithTTL.
func (mr *MockDBMockRecorder) UpdateTaskListWithTTL(ctx, ttlSeconds, row, previousRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskListWithTTL", reflect.TypeOf((*MockDB)(nil).UpdateTaskListWithTTL), ctx, ttlSeconds, row, previousRangeID)
}

// UpdateVisibility mocks base method.
func (m *MockDB) UpdateVisibility(ctx context.Context, ttlSeconds int64, row *VisibilityRowForUpdate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateVisibility", ctx, ttlSeconds, row)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateVisibility indicates an expected call of UpdateVisibility.
func (mr *MockDBMockRecorder) UpdateVisibility(ctx, ttlSeconds, row interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateVisibility", reflect.TypeOf((*MockDB)(nil).UpdateVisibility), ctx, ttlSeconds, row)
}

// UpdateWorkflowExecutionWithTasks mocks base method.
func (m *MockDB) UpdateWorkflowExecutionWithTasks(ctx context.Context, currentWorkflowRequest *CurrentWorkflowWriteRequest, mutatedExecution, insertedExecution, resetExecution *WorkflowExecutionRequest, transferTasks []*TransferTask, crossClusterTasks []*CrossClusterTask, replicationTasks []*ReplicationTask, timerTasks []*TimerTask, shardCondition *ShardCondition) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkflowExecutionWithTasks", ctx, currentWorkflowRequest, mutatedExecution, insertedExecution, resetExecution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkflowExecutionWithTasks indicates an expected call of UpdateWorkflowExecutionWithTasks.
func (mr *MockDBMockRecorder) UpdateWorkflowExecutionWithTasks(ctx, currentWorkflowRequest, mutatedExecution, insertedExecution, resetExecution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkflowExecutionWithTasks", reflect.TypeOf((*MockDB)(nil).UpdateWorkflowExecutionWithTasks), ctx, currentWorkflowRequest, mutatedExecution, insertedExecution, resetExecution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition)
}

// MocktableCRUD is a mock of tableCRUD interface.
type MocktableCRUD struct {
	ctrl     *gomock.Controller
	recorder *MocktableCRUDMockRecorder
}

// MocktableCRUDMockRecorder is the mock recorder for MocktableCRUD.
type MocktableCRUDMockRecorder struct {
	mock *MocktableCRUD
}

// NewMocktableCRUD creates a new mock instance.
func NewMocktableCRUD(ctrl *gomock.Controller) *MocktableCRUD {
	mock := &MocktableCRUD{ctrl: ctrl}
	mock.recorder = &MocktableCRUDMockRecorder{mock}
	return mock
}

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

// DeleteCrossClusterTask mocks base method.
func (m *MocktableCRUD) DeleteCrossClusterTask(ctx context.Context, shardID int, targetCluster string, taskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCrossClusterTask", ctx, shardID, targetCluster, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCrossClusterTask indicates an expected call of DeleteCrossClusterTask.
func (mr *MocktableCRUDMockRecorder) DeleteCrossClusterTask(ctx, shardID, targetCluster, taskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCrossClusterTask", reflect.TypeOf((*MocktableCRUD)(nil).DeleteCrossClusterTask), ctx, shardID, targetCluster, taskID)
}

// DeleteCurrentWorkflow mocks base method.
func (m *MocktableCRUD) DeleteCurrentWorkflow(ctx context.Context, shardID int, domainID, workflowID, currentRunIDCondition string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCurrentWorkflow", ctx, shardID, domainID, workflowID, currentRunIDCondition)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCurrentWorkflow indicates an expected call of DeleteCurrentWorkflow.
func (mr *MocktableCRUDMockRecorder) DeleteCurrentWorkflow(ctx, shardID, domainID, workflowID, currentRunIDCondition interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCurrentWorkflow", reflect.TypeOf((*MocktableCRUD)(nil).DeleteCurrentWorkflow), ctx, shardID, domainID, workflowID, currentRunIDCondition)
}

// DeleteDomain mocks base method.
func (m *MocktableCRUD) DeleteDomain(ctx context.Context, domainID, domainName *string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDomain", ctx, domainID, domainName)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDomain indicates an expected call of DeleteDomain.
func (mr *MocktableCRUDMockRecorder) DeleteDomain(ctx, domainID, domainName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDomain", reflect.TypeOf((*MocktableCRUD)(nil).DeleteDomain), ctx, domainID, domainName)
}

// DeleteFromHistoryTreeAndNode mocks base method.
func (m *MocktableCRUD) DeleteFromHistoryTreeAndNode(ctx context.Context, treeFilter *HistoryTreeFilter, nodeFilters []*HistoryNodeFilter) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromHistoryTreeAndNode", ctx, treeFilter, nodeFilters)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteFromHistoryTreeAndNode indicates an expected call of DeleteFromHistoryTreeAndNode.
func (mr *MocktableCRUDMockRecorder) DeleteFromHistoryTreeAndNode(ctx, treeFilter, nodeFilters interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFromHistoryTreeAndNode", reflect.TypeOf((*MocktableCRUD)(nil).DeleteFromHistoryTreeAndNode), ctx, treeFilter, nodeFilters)
}

// DeleteMessage mocks base method.
func (m *MocktableCRUD) DeleteMessage(ctx context.Context, queueType persistence.QueueType, messageID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessage", ctx, queueType, messageID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMessage indicates an expected call of DeleteMessage.
func (mr *MocktableCRUDMockRecorder) DeleteMessage(ctx, queueType, messageID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessage", reflect.TypeOf((*MocktableCRUD)(nil).DeleteMessage), ctx, queueType, messageID)
}

// DeleteMessagesBefore mocks base method.
func (m *MocktableCRUD) DeleteMessagesBefore(ctx context.Context, queueType persistence.QueueType, exclusiveBeginMessageID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessagesBefore", ctx, queueType, exclusiveBeginMessageID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMessagesBefore indicates an expected call of DeleteMessagesBefore.
func (mr *MocktableCRUDMockRecorder) DeleteMessagesBefore(ctx, queueType, exclusiveBeginMessageID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessagesBefore", reflect.TypeOf((*MocktableCRUD)(nil).DeleteMessagesBefore), ctx, queueType, exclusiveBeginMessageID)
}

// DeleteMessagesInRange mocks base method.
func (m *MocktableCRUD) DeleteMessagesInRange(ctx context.Context, queueType persistence.QueueType, exclusiveBeginMessageID, inclusiveEndMessageID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessagesInRange", ctx, queueType, exclusiveBeginMessageID, inclusiveEndMessageID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMessagesInRange indicates an expected call of DeleteMessagesInRange.
func (mr *MocktableCRUDMockRecorder) DeleteMessagesInRange(ctx, queueType, exclusiveBeginMessageID, inclusiveEndMessageID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessagesInRange", reflect.TypeOf((*MocktableCRUD)(nil).DeleteMessagesInRange), ctx, queueType, exclusiveBeginMessageID, inclusiveEndMessageID)
}

// DeleteReplicationDLQTask mocks base method.
func (m *MocktableCRUD) DeleteReplicationDLQTask(ctx context.Context, shardID int, sourceCluster string, taskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReplicationDLQTask", ctx, shardID, sourceCluster, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteReplicationDLQTask indicates an expected call of DeleteReplicationDLQTask.
func (mr *MocktableCRUDMockRecorder) DeleteReplicationDLQTask(ctx, shardID, sourceCluster, taskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationDLQTask", reflect.TypeOf((*MocktableCRUD)(nil).DeleteReplicationDLQTask), ctx, shardID, sourceCluster, taskID)
}

// DeleteReplicationTask mocks base method.
func (m *MocktableCRUD) DeleteReplicationTask(ctx context.Context, shardID int, taskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReplicationTask", ctx, shardID, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteReplicationTask indicates an expected call of DeleteReplicationTask.
func (mr *MocktableCRUDMockRecorder) DeleteReplicationTask(ctx, shardID, taskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationTask", reflect.TypeOf((*MocktableCRUD)(nil).DeleteReplicationTask), ctx, shardID, taskID)
}

// DeleteTaskList mocks base method.
func (m *MocktableCRUD) DeleteTaskList(ctx context.Context, filter *TaskListFilter, previousRangeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTaskList", ctx, filter, previousRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTaskList indicates an expected call of DeleteTaskList.
func (mr *MocktableCRUDMockRecorder) DeleteTaskList(ctx, filter, previousRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTaskList", reflect.TypeOf((*MocktableCRUD)(nil).DeleteTaskList), ctx, filter, previousRangeID)
}

// DeleteTimerTask mocks base method.
func (m *MocktableCRUD) DeleteTimerTask(ctx context.Context, shardID int, taskID int64, visibilityTimestamp time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTimerTask", ctx, shardID, taskID, visibilityTimestamp)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTimerTask indicates an expected call of DeleteTimerTask.
func (mr *MocktableCRUDMockRecorder) DeleteTimerTask(ctx, shardID, taskID, visibilityTimestamp interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTimerTask", reflect.TypeOf((*MocktableCRUD)(nil).DeleteTimerTask), ctx, shardID, taskID, visibilityTimestamp)
}

// DeleteTransferTask mocks base method.
func (m *MocktableCRUD) DeleteTransferTask(ctx context.Context, shardID int, taskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransferTask", ctx, shardID, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTransferTask indicates an expected call of DeleteTransferTask.
func (mr *MocktableCRUDMockRecorder) DeleteTransferTask(ctx, shardID, taskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransferTask", reflect.TypeOf((*MocktableCRUD)(nil).DeleteTransferTask), ctx, shardID, taskID)
}

// DeleteVisibility mocks base method.
func (m *MocktableCRUD) DeleteVisibility(ctx context.Context, domainID, workflowID, runID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVisibility", ctx, domainID, workflowID, runID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteVisibility indicates an expected call of DeleteVisibility.
func (mr *MocktableCRUDMockRecorder) DeleteVisibility(ctx, domainID, workflowID, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVisibility", reflect.TypeOf((*MocktableCRUD)(nil).DeleteVisibility), ctx, domainID, workflowID, runID)
}

// DeleteWorkflowExecution mocks base method.
func (m *MocktableCRUD) DeleteWorkflowExecution(ctx context.Context, shardID int, domainID, workflowID, runID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkflowExecution", ctx, shardID, domainID, workflowID, runID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteWorkflowExecution indicates an expected call of DeleteWorkflowExecution.
func (mr *MocktableCRUDMockRecorder) DeleteWorkflowExecution(ctx, shardID, domainID, workflowID, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkflowExecution", reflect.TypeOf((*MocktableCRUD)(nil).DeleteWorkflowExecution), ctx, shardID, domainID, workflowID, runID)
}

// GetQueueSize mocks base method.
func (m *MocktableCRUD) GetQueueSize(ctx context.Context, queueType persistence.QueueType) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueueSize", ctx, queueType)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// InsertConfig mocks base method.
func (m *MocktableCRUD) InsertConfig(ctx context.Context, row *persistence.InternalConfigStoreEntry) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertConfig", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertDomain mocks base method.
func (m *MocktableCRUD) InsertDomain(ctx context.Context, row *DomainRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertDomain", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertIntoHistoryTreeAndNode mocks base method.
func (m *MocktableCRUD) InsertIntoHistoryTreeAndNode(ctx context.Context, treeRow *HistoryTreeRow, nodeRow *HistoryNodeRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoHistoryTreeAndNode", ctx, treeRow, nodeRow)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertIntoHistoryTreeAndNode indicates an expected call of InsertIntoHistoryTreeAndNode.
func (mr *MocktableCRUDMockRecorder) InsertIntoHistoryTreeAndNode(ctx, treeRow, nodeRow interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertIntoHistoryTreeAndNode", reflect.TypeOf((*MocktableCRUD)(nil).InsertIntoHistoryTreeAndNode), ctx, treeRow, nodeRow)
}

// InsertIntoQueue mocks base method.
func (m *MocktableCRUD) InsertIntoQueue(ctx context.Context, row *QueueMessageRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoQueue", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertQueueMetadata mocks base method.
func (m *MocktableCRUD) InsertQueueMetadata(ctx context.Context, queueType persistence.QueueType, version int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertQueueMetadata", ctx, queueType, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertQueueMetadata indicates an expected call of InsertQueueMetadata.
func (mr *MocktableCRUDMockRecorder) InsertQueueMetadata(ctx, queueType, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertQueueMetadata", reflect.TypeOf((*MocktableCRUD)(nil).InsertQueueMetadata), ctx, queueType, version)
}

// InsertReplicationDLQTask mocks base method.
func (m *MocktableCRUD) InsertReplicationDLQTask(ctx context.Context, shardID int, sourceCluster string, task ReplicationTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertReplicationDLQTask", ctx, shardID, sourceCluster, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertReplicationDLQTask indicates an expected call of InsertReplicationDLQTask.
func (mr *MocktableCRUDMockRecorder) InsertReplicationDLQTask(ctx, shardID, sourceCluster, task interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertReplicationDLQTask", reflect.TypeOf((*MocktableCRUD)(nil).InsertReplicationDLQTask), ctx, shardID, sourceCluster, task)
}

// InsertReplicationTask mocks base method.
func (m *MocktableCRUD) InsertReplicationTask(ctx context.Context, tasks []*ReplicationTask, condition ShardCondition) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertReplicationTask", ctx, tasks, condition)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertReplicationTask indicates an expected call of InsertReplicationTask.
func (mr *MocktableCRUDMockRecorder) InsertReplicationTask(ctx, tasks, condition interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertReplicationTask", reflect.TypeOf((*MocktableCRUD)(nil).InsertReplicationTask), ctx, tasks, condition)
}

// InsertShard mocks base method.
func (m *MocktableCRUD) InsertShard(ctx context.Context, row *ShardRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertShard", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertTaskList mocks base method.
func (m *MocktableCRUD) InsertTaskList(ctx context.Context, row *TaskListRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTaskList", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertTasks mocks base method.
func (m *MocktableCRUD) InsertTasks(ctx context.Context, tasksToInsert []*TaskRowForInsert, tasklistCondition *TaskListRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTasks", ctx, tasksToInsert, tasklistCondition)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertTasks indicates an expected call of InsertTasks.
func (mr *MocktableCRUDMockRecorder) InsertTasks(ctx, tasksToInsert, tasklistCondition interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertTasks", reflect.TypeOf((*MocktableCRUD)(nil).InsertTasks), ctx, tasksToInsert, tasklistCondition)
}

// InsertVisibility mocks base method.
func (m *MocktableCRUD) InsertVisibility(ctx context.Context, ttlSeconds int64, row *VisibilityRowForInsert) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertVisibility", ctx, ttlSeconds, row)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertVisibility indicates an expected call of InsertVisibility.
func (mr *MocktableCRUDMockRecorder) InsertVisibility(ctx, ttlSeconds, row interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertVisibility", reflect.TypeOf((*MocktableCRUD)(nil).InsertVisibility), ctx, ttlSeconds, row)
}

// InsertWorkflowExecutionWithTasks mocks base method.
func (m *MocktableCRUD) InsertWorkflowExecutionWithTasks(ctx context.Context, currentWorkflowRequest *CurrentWorkflowWriteRequest, execution *WorkflowExecutionRequest, transferTasks []*TransferTask, crossClusterTasks []*CrossClusterTask, replicationTasks []*ReplicationTask, timerTasks []*TimerTask, shardCondition *ShardCondition) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkflowExecutionWithTasks", ctx, currentWorkflowRequest, execution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertWorkflowExecutionWithTasks indicates an expected call of InsertWorkflowExecutionWithTasks.
func (mr *MocktableCRUDMockRecorder) InsertWorkflowExecutionWithTasks(ctx, currentWorkflowRequest, execution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkflowExecutionWithTasks", reflect.TypeOf((*MocktableCRUD)(nil).InsertWorkflowExecutionWithTasks), ctx, currentWorkflowRequest, execution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition)
}

// IsWorkflowExecutionExists mocks base method.
func (m *MocktableCRUD) IsWorkflowExecutionExists(ctx context.Context, shardID int, domainID, workflowID, runID string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsWorkflowExecutionExists", ctx, shardID, domainID, workflowID, runID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsWorkflowExecutionExists indicates an expected call of IsWorkflowExecutionExists.
func (mr *MocktableCRUDMockRecorder) IsWorkflowExecutionExists(ctx, shardID, domainID, workflowID, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsWorkflowExecutionExists", reflect.TypeOf((*MocktableCRUD)(nil).IsWorkflowExecutionExists), ctx, shardID, domainID, workflowID, runID)
}

// ListTaskList mocks base method.
func (m *MocktableCRUD) ListTaskList(ctx context.Context, pageSize int, nextPageToken []byte) (*ListTaskListResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTaskList", ctx, pageSize, nextPageToken)
	ret0, _ := ret[0].(*ListTaskListResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTaskList indicates an expected call of ListTaskList.
func (mr *MocktableCRUDMockRecorder) ListTaskList(ctx, pageSize, nextPageToken interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskList", reflect.TypeOf((*MocktableCRUD)(nil).ListTaskList), ctx, pageSize, nextPageToken)
}

// RangeDeleteCrossClusterTasks mocks base method.
func (m *MocktableCRUD) RangeDeleteCrossClusterTasks(ctx context.Context, shardID int, targetCluster string, exclusiveBeginTaskID, inclusiveEndTaskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteCrossClusterTasks", ctx, shardID, targetCluster, exclusiveBeginTaskID, inclusiveEndTaskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteCrossClusterTasks indicates an expected call of RangeDeleteCrossClusterTasks.
func (mr *MocktableCRUDMockRecorder) RangeDeleteCrossClusterTasks(ctx, shardID, targetCluster, exclusiveBeginTaskID, inclusiveEndTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteCrossClusterTasks", reflect.TypeOf((*MocktableCRUD)(nil).RangeDeleteCrossClusterTasks), ctx, shardID, targetCluster, exclusiveBeginTaskID, inclusiveEndTaskID)
}

// RangeDeleteReplicationDLQTasks mocks base method.
func (m *MocktableCRUD) RangeDeleteReplicationDLQTasks(ctx context.Context, shardID int, sourceCluster string, exclusiveBeginTaskID, inclusiveEndTaskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteReplicationDLQTasks", ctx, shardID, sourceCluster, exclusiveBeginTaskID, inclusiveEndTaskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteReplicationDLQTasks indicates an expected call of RangeDeleteReplicationDLQTasks.
func (mr *MocktableCRUDMockRecorder) RangeDeleteReplicationDLQTasks(ctx, shardID, sourceCluster, exclusiveBeginTaskID, inclusiveEndTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteReplicationDLQTasks", reflect.TypeOf((*MocktableCRUD)(nil).RangeDeleteReplicationDLQTasks), ctx, shardID, sourceCluster, exclusiveBeginTaskID, inclusiveEndTaskID)
}

// RangeDeleteReplicationTasks mocks base method.
func (m *MocktableCRUD) RangeDeleteReplicationTasks(ctx context.Context, shardID int, inclusiveEndTaskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteReplicationTasks", ctx, shardID, inclusiveEndTaskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteReplicationTasks indicates an expected call of RangeDeleteReplicationTasks.
func (mr *MocktableCRUDMockRecorder) RangeDeleteReplicationTasks(ctx, shardID, inclusiveEndTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteReplicationTasks", reflect.TypeOf((*MocktableCRUD)(nil).RangeDeleteReplicationTasks), ctx, shardID, inclusiveEndTaskID)
}

// RangeDeleteTasks mocks base method.
func (m *MocktableCRUD) RangeDeleteTasks(ctx context.Context, filter *TasksFilter) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteTasks", ctx, filter)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RangeDeleteTimerTasks mocks base method.
func (m *MocktableCRUD) RangeDeleteTimerTasks(ctx context.Context, shardID int, inclusiveMinTime, exclusiveMaxTime time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteTimerTasks", ctx, shardID, inclusiveMinTime, exclusiveMaxTime)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteTimerTasks indicates an expected call of RangeDeleteTimerTasks.
func (mr *MocktableCRUDMockRecorder) RangeDeleteTimerTasks(ctx, shardID, inclusiveMinTime, exclusiveMaxTime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteTimerTasks", reflect.TypeOf((*MocktableCRUD)(nil).RangeDeleteTimerTasks), ctx, shardID, inclusiveMinTime, exclusiveMaxTime)
}

// RangeDeleteTransferTasks mocks base method.
func (m *MocktableCRUD) RangeDeleteTransferTasks(ctx context.Context, shardID int, exclusiveBeginTaskID, inclusiveEndTaskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteTransferTasks", ctx, shardID, exclusiveBeginTaskID, inclusiveEndTaskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteTransferTasks indicates an expected call of RangeDeleteTransferTasks.
func (mr *MocktableCRUDMockRecorder) RangeDeleteTransferTasks(ctx, shardID, exclusiveBeginTaskID, inclusiveEndTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteTransferTasks", reflect.TypeOf((*MocktableCRUD)(nil).RangeDeleteTransferTasks), ctx, shardID, exclusiveBeginTaskID, inclusiveEndTaskID)
}

// SelectAllCurrentWorkflows mocks base method.
func (m *MocktableCRUD) SelectAllCurrentWorkflows(ctx context.Context, shardID int, pageToken []byte, pageSize int) ([]*persistence.CurrentWorkflowExecution, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectAllCurrentWorkflows", ctx, shardID, pageToken, pageSize)
	ret0, _ := ret[0].([]*persistence.CurrentWorkflowExecution)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectAllCurrentWorkflows indicates an expected call of SelectAllCurrentWorkflows.
func (mr *MocktableCRUDMockRecorder) SelectAllCurrentWorkflows(ctx, shardID, pageToken, pageSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAllCurrentWorkflows", reflect.TypeOf((*MocktableCRUD)(nil).SelectAllCurrentWorkflows), ctx, shardID, pageToken, pageSize)
}

// SelectAllDomains mocks base method.
func (m *MocktableCRUD) SelectAllDomains(ctx context.Context, pageSize int, pageToken []byte) ([]*DomainRow, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectAllDomains", ctx, pageSize, pageToken)
	ret0, _ := ret[0].([]*DomainRow)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectAllDomains indicates an expected call of SelectAllDomains.
func (mr *MocktableCRUDMockRecorder) SelectAllDomains(ctx, pageSize, pageToken interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAllDomains", reflect.TypeOf((*MocktableCRUD)(nil).SelectAllDomains), ctx, pageSize, pageToken)
}

// SelectAllHistoryTrees mocks base method.
func (m *MocktableCRUD) SelectAllHistoryTrees(ctx context.Context, nextPageToken []byte, pageSize int) ([]*HistoryTreeRow, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectAllHistoryTrees", ctx, nextPageToken, pageSize)
	ret0, _ := ret[0].([]*HistoryTreeRow)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectAllHistoryTrees indicates an expected call of SelectAllHistoryTrees.
func (mr *MocktableCRUDMockRecorder) SelectAllHistoryTrees(ctx, nextPageToken, pageSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAllHistoryTrees", reflect.TypeOf((*MocktableCRUD)(nil).SelectAllHistoryTrees), ctx, nextPageToken, pageSize)
}

// SelectAllWorkflowExecutions mocks base method.
func (m *MocktableCRUD) SelectAllWorkflowExecutions(ctx context.Context, shardID int, pageToken []byte, pageSize int) ([]*persistence.InternalListConcreteExecutionsEntity, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectAllWorkflowExecutions", ctx, shardID, pageToken, pageSize)
	ret0, _ := ret[0].([]*persistence.InternalListConcreteExecutionsEntity)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectAllWorkflowExecutions indicates an expected call of SelectAllWorkflowExecutions.
func (mr *MocktableCRUDMockRecorder) SelectAllWorkflowExecutions(ctx, shardID, pageToken, pageSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAllWorkflowExecutions", reflect.TypeOf((*MocktableCRUD)(nil).SelectAllWorkflowExecutions), ctx, shardID, pageToken, pageSize)
}

// SelectCrossClusterTasksOrderByTaskID mocks base method.
func (m *MocktableCRUD) SelectCrossClusterTasksOrderByTaskID(ctx context.Context, shardID, pageSize int, pageToken []byte, targetCluster string, exclusiveMinTaskID, inclusiveMaxTaskID int64) ([]*CrossClusterTask, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectCrossClusterTasksOrderByTaskID", ctx, shardID, pageSize, pageToken, targetCluster, exclusiveMinTaskID, inclusiveMaxTaskID)
	ret0, _ := ret[0].([]*CrossClusterTask)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectCrossClusterTasksOrderByTaskID indicates an expected call of SelectCrossClusterTasksOrderByTaskID.
func (mr *MocktableCRUDMockRecorder) SelectCrossClusterTasksOrderByTaskID(ctx, shardID, pageSize, pageToken, targetCluster, exclusiveMinTaskID, inclusiveMaxTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectCrossClusterTasksOrderByTaskID", reflect.TypeOf((*MocktableCRUD)(nil).SelectCrossClusterTasksOrderByTaskID), ctx, shardID, pageSize, pageToken, targetCluster, exclusiveMinTaskID, inclusiveMaxTaskID)
}

// SelectCurrentWorkflow mocks base method.
func (m *MocktableCRUD) SelectCurrentWorkflow(ctx context.Context, shardID int, domainID, workflowID string) (*CurrentWorkflowRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectCurrentWorkflow", ctx, shardID, domainID, workflowID)
	ret0, _ := ret[0].(*CurrentWorkflowRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectCurrentWorkflow indicates an expected call of SelectCurrentWorkflow.
func (mr *MocktableCRUDMockRecorder) SelectCurrentWorkflow(ctx, shardID, domainID, workflowID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectCurrentWorkflow", reflect.TypeOf((*MocktableCRUD)(nil).SelectCurrentWorkflow), ctx, shardID, domainID, workflowID)
}

// SelectDomain mocks base method.
func (m *MocktableCRUD) SelectDomain(ctx context.Context, domainID, domainName *string) (*DomainRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectDomain", ctx, domainID, domainName)
	ret0, _ := ret[0].(*DomainRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectDomain indicates an expected call of SelectDomain.
func (mr *MocktableCRUDMockRecorder) SelectDomain(ctx, domainID, domainName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectDomain", reflect.TypeOf((*MocktableCRUD)(nil).SelectDomain), ctx, domainID, domainName)
}

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

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

// SelectFromHistoryNode mocks base method.
func (m *MocktableCRUD) SelectFromHistoryNode(ctx context.Context, filter *HistoryNodeFilter) ([]*HistoryNodeRow, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectFromHistoryNode", ctx, filter)
	ret0, _ := ret[0].([]*HistoryNodeRow)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// SelectFromHistoryTree mocks base method.
func (m *MocktableCRUD) SelectFromHistoryTree(ctx context.Context, filter *HistoryTreeFilter) ([]*HistoryTreeRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectFromHistoryTree", ctx, filter)
	ret0, _ := ret[0].([]*HistoryTreeRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectLastEnqueuedMessageID mocks base method.
func (m *MocktableCRUD) SelectLastEnqueuedMessageID(ctx context.Context, queueType persistence.QueueType) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectLastEnqueuedMessageID", ctx, queueType)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectLatestConfig mocks base method.
func (m *MocktableCRUD) SelectLatestConfig(ctx context.Context, rowType int) (*persistence.InternalConfigStoreEntry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectLatestConfig", ctx, rowType)
	ret0, _ := ret[0].(*persistence.InternalConfigStoreEntry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectMessagesBetween mocks base method.
func (m *MocktableCRUD) SelectMessagesBetween(ctx context.Context, request SelectMessagesBetweenRequest) (*SelectMessagesBetweenResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectMessagesBetween", ctx, request)
	ret0, _ := ret[0].(*SelectMessagesBetweenResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectMessagesFrom mocks base method.
func (m *MocktableCRUD) SelectMessagesFrom(ctx context.Context, queueType persistence.QueueType, exclusiveBeginMessageID int64, maxRows int) ([]*QueueMessageRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectMessagesFrom", ctx, queueType, exclusiveBeginMessageID, maxRows)
	ret0, _ := ret[0].([]*QueueMessageRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectMessagesFrom indicates an expected call of SelectMessagesFrom.
func (mr *MocktableCRUDMockRecorder) SelectMessagesFrom(ctx, queueType, exclusiveBeginMessageID, maxRows interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectMessagesFrom", reflect.TypeOf((*MocktableCRUD)(nil).SelectMessagesFrom), ctx, queueType, exclusiveBeginMessageID, maxRows)
}

// SelectOneClosedWorkflow mocks base method.
func (m *MocktableCRUD) SelectOneClosedWorkflow(ctx context.Context, domainID, workflowID, runID string) (*VisibilityRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectOneClosedWorkflow", ctx, domainID, workflowID, runID)
	ret0, _ := ret[0].(*VisibilityRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectOneClosedWorkflow indicates an expected call of SelectOneClosedWorkflow.
func (mr *MocktableCRUDMockRecorder) SelectOneClosedWorkflow(ctx, domainID, workflowID, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectOneClosedWorkflow", reflect.TypeOf((*MocktableCRUD)(nil).SelectOneClosedWorkflow), ctx, domainID, workflowID, runID)
}

// SelectQueueMetadata mocks base method.
func (m *MocktableCRUD) SelectQueueMetadata(ctx context.Context, queueType persistence.QueueType) (*QueueMetadataRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectQueueMetadata", ctx, queueType)
	ret0, _ := ret[0].(*QueueMetadataRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectReplicationDLQTasksCount mocks base method.
func (m *MocktableCRUD) SelectReplicationDLQTasksCount(ctx context.Context, shardID int, sourceCluster string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectReplicationDLQTasksCount", ctx, shardID, sourceCluster)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectReplicationDLQTasksCount indicates an expected call of SelectReplicationDLQTasksCount.
func (mr *MocktableCRUDMockRecorder) SelectReplicationDLQTasksCount(ctx, shardID, sourceCluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectReplicationDLQTasksCount", reflect.TypeOf((*MocktableCRUD)(nil).SelectReplicationDLQTasksCount), ctx, shardID, sourceCluster)
}

// SelectReplicationDLQTasksOrderByTaskID mocks base method.
func (m *MocktableCRUD) SelectReplicationDLQTasksOrderByTaskID(ctx context.Context, shardID int, sourceCluster string, pageSize int, pageToken []byte, exclusiveMinTaskID, inclusiveMaxTaskID int64) ([]*ReplicationTask, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectReplicationDLQTasksOrderByTaskID", ctx, shardID, sourceCluster, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
	ret0, _ := ret[0].([]*ReplicationTask)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectReplicationDLQTasksOrderByTaskID indicates an expected call of SelectReplicationDLQTasksOrderByTaskID.
func (mr *MocktableCRUDMockRecorder) SelectReplicationDLQTasksOrderByTaskID(ctx, shardID, sourceCluster, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectReplicationDLQTasksOrderByTaskID", reflect.TypeOf((*MocktableCRUD)(nil).SelectReplicationDLQTasksOrderByTaskID), ctx, shardID, sourceCluster, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
}

// SelectReplicationTasksOrderByTaskID mocks base method.
func (m *MocktableCRUD) SelectReplicationTasksOrderByTaskID(ctx context.Context, shardID, pageSize int, pageToken []byte, exclusiveMinTaskID, inclusiveMaxTaskID int64) ([]*ReplicationTask, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectReplicationTasksOrderByTaskID", ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
	ret0, _ := ret[0].([]*ReplicationTask)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectReplicationTasksOrderByTaskID indicates an expected call of SelectReplicationTasksOrderByTaskID.
func (mr *MocktableCRUDMockRecorder) SelectReplicationTasksOrderByTaskID(ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectReplicationTasksOrderByTaskID", reflect.TypeOf((*MocktableCRUD)(nil).SelectReplicationTasksOrderByTaskID), ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
}

// SelectShard mocks base method.
func (m *MocktableCRUD) SelectShard(ctx context.Context, shardID int, currentClusterName string) (int64, *ShardRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectShard", ctx, shardID, currentClusterName)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(*ShardRow)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectShard indicates an expected call of SelectShard.
func (mr *MocktableCRUDMockRecorder) SelectShard(ctx, shardID, currentClusterName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectShard", reflect.TypeOf((*MocktableCRUD)(nil).SelectShard), ctx, shardID, currentClusterName)
}

// SelectTaskList mocks base method.
func (m *MocktableCRUD) SelectTaskList(ctx context.Context, filter *TaskListFilter) (*TaskListRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectTaskList", ctx, filter)
	ret0, _ := ret[0].(*TaskListRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectTasks mocks base method.
func (m *MocktableCRUD) SelectTasks(ctx context.Context, filter *TasksFilter) ([]*TaskRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectTasks", ctx, filter)
	ret0, _ := ret[0].([]*TaskRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectTimerTasksOrderByVisibilityTime mocks base method.
func (m *MocktableCRUD) SelectTimerTasksOrderByVisibilityTime(ctx context.Context, shardID, pageSize int, pageToken []byte, inclusiveMinTime, exclusiveMaxTime time.Time) ([]*TimerTask, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectTimerTasksOrderByVisibilityTime", ctx, shardID, pageSize, pageToken, inclusiveMinTime, exclusiveMaxTime)
	ret0, _ := ret[0].([]*TimerTask)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectTimerTasksOrderByVisibilityTime indicates an expected call of SelectTimerTasksOrderByVisibilityTime.
func (mr *MocktableCRUDMockRecorder) SelectTimerTasksOrderByVisibilityTime(ctx, shardID, pageSize, pageToken, inclusiveMinTime, exclusiveMaxTime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectTimerTasksOrderByVisibilityTime", reflect.TypeOf((*MocktableCRUD)(nil).SelectTimerTasksOrderByVisibilityTime), ctx, shardID, pageSize, pageToken, inclusiveMinTime, exclusiveMaxTime)
}

// SelectTransferTasksOrderByTaskID mocks base method.
func (m *MocktableCRUD) SelectTransferTasksOrderByTaskID(ctx context.Context, shardID, pageSize int, pageToken []byte, exclusiveMinTaskID, inclusiveMaxTaskID int64) ([]*TransferTask, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectTransferTasksOrderByTaskID", ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
	ret0, _ := ret[0].([]*TransferTask)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectTransferTasksOrderByTaskID indicates an expected call of SelectTransferTasksOrderByTaskID.
func (mr *MocktableCRUDMockRecorder) SelectTransferTasksOrderByTaskID(ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectTransferTasksOrderByTaskID", reflect.TypeOf((*MocktableCRUD)(nil).SelectTransferTasksOrderByTaskID), ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
}

// SelectVisibility mocks base method.
func (m *MocktableCRUD) SelectVisibility(ctx context.Context, filter *VisibilityFilter) (*SelectVisibilityResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectVisibility", ctx, filter)
	ret0, _ := ret[0].(*SelectVisibilityResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectWorkflowExecution mocks base method.
func (m *MocktableCRUD) SelectWorkflowExecution(ctx context.Context, shardID int, domainID, workflowID, runID string) (*WorkflowExecution, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectWorkflowExecution", ctx, shardID, domainID, workflowID, runID)
	ret0, _ := ret[0].(*WorkflowExecution)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectWorkflowExecution indicates an expected call of SelectWorkflowExecution.
func (mr *MocktableCRUDMockRecorder) SelectWorkflowExecution(ctx, shardID, domainID, workflowID, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectWorkflowExecution", reflect.TypeOf((*MocktableCRUD)(nil).SelectWorkflowExecution), ctx, shardID, domainID, workflowID, runID)
}

// UpdateDomain mocks base method.
func (m *MocktableCRUD) UpdateDomain(ctx context.Context, row *DomainRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDomain", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateQueueMetadataCas mocks base method.
func (m *MocktableCRUD) UpdateQueueMetadataCas(ctx context.Context, row QueueMetadataRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateQueueMetadataCas", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateRangeID mocks base method.
func (m *MocktableCRUD) UpdateRangeID(ctx context.Context, shardID int, rangeID, previousRangeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRangeID", ctx, shardID, rangeID, previousRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateRangeID indicates an expected call of UpdateRangeID.
func (mr *MocktableCRUDMockRecorder) UpdateRangeID(ctx, shardID, rangeID, previousRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRangeID", reflect.TypeOf((*MocktableCRUD)(nil).UpdateRangeID), ctx, shardID, rangeID, previousRangeID)
}

// UpdateShard mocks base method.
func (m *MocktableCRUD) UpdateShard(ctx context.Context, row *ShardRow, previousRangeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateShard", ctx, row, previousRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateShard indicates an expected call of UpdateShard.
func (mr *MocktableCRUDMockRecorder) UpdateShard(ctx, row, previousRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateShard", reflect.TypeOf((*MocktableCRUD)(nil).UpdateShard), ctx, row, previousRangeID)
}

// UpdateTaskList mocks base method.
func (m *MocktableCRUD) UpdateTaskList(ctx context.Context, row *TaskListRow, previousRangeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskList", ctx, row, previousRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTaskList indicates an expected call of UpdateTaskList.
func (mr *MocktableCRUDMockRecorder) UpdateTaskList(ctx, row, previousRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskList", reflect.TypeOf((*MocktableCRUD)(nil).UpdateTaskList), ctx, row, previousRangeID)
}

// UpdateTaskListWithTTL mocks base method.
func (m *MocktableCRUD) UpdateTaskListWithTTL(ctx context.Context, ttlSeconds int64, row *TaskListRow, previousRangeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskListWithTTL", ctx, ttlSeconds, row, previousRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTaskListWithTTL indicates an expected call of UpdateTaskListWithTTL.
func (mr *MocktableCRUDMockRecorder) UpdateTaskListWithTTL(ctx, ttlSeconds, row, previousRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskListWithTTL", reflect.TypeOf((*MocktableCRUD)(nil).UpdateTaskListWithTTL), ctx, ttlSeconds, row, previousRangeID)
}

// UpdateVisibility mocks base method.
func (m *MocktableCRUD) UpdateVisibility(ctx context.Context, ttlSeconds int64, row *VisibilityRowForUpdate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateVisibility", ctx, ttlSeconds, row)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateVisibility indicates an expected call of UpdateVisibility.
func (mr *MocktableCRUDMockRecorder) UpdateVisibility(ctx, ttlSeconds, row interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateVisibility", reflect.TypeOf((*MocktableCRUD)(nil).UpdateVisibility), ctx, ttlSeconds, row)
}

// UpdateWorkflowExecutionWithTasks mocks base method.
func (m *MocktableCRUD) UpdateWorkflowExecutionWithTasks(ctx context.Context, currentWorkflowRequest *CurrentWorkflowWriteRequest, mutatedExecution, insertedExecution, resetExecution *WorkflowExecutionRequest, transferTasks []*TransferTask, crossClusterTasks []*CrossClusterTask, replicationTasks []*ReplicationTask, timerTasks []*TimerTask, shardCondition *ShardCondition) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkflowExecutionWithTasks", ctx, currentWorkflowRequest, mutatedExecution, insertedExecution, resetExecution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkflowExecutionWithTasks indicates an expected call of UpdateWorkflowExecutionWithTasks.
func (mr *MocktableCRUDMockRecorder) UpdateWorkflowExecutionWithTasks(ctx, currentWorkflowRequest, mutatedExecution, insertedExecution, resetExecution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkflowExecutionWithTasks", reflect.TypeOf((*MocktableCRUD)(nil).UpdateWorkflowExecutionWithTasks), ctx, currentWorkflowRequest, mutatedExecution, insertedExecution, resetExecution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition)
}

// MockClientErrorChecker is a mock of ClientErrorChecker interface.
type MockClientErrorChecker struct {
	ctrl     *gomock.Controller
	recorder *MockClientErrorCheckerMockRecorder
}

// MockClientErrorCheckerMockRecorder is the mock recorder for MockClientErrorChecker.
type MockClientErrorCheckerMockRecorder struct {
	mock *MockClientErrorChecker
}

// NewMockClientErrorChecker creates a new mock instance.
func NewMockClientErrorChecker(ctrl *gomock.Controller) *MockClientErrorChecker {
	mock := &MockClientErrorChecker{ctrl: ctrl}
	mock.recorder = &MockClientErrorCheckerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// MockHistoryEventsCRUD is a mock of HistoryEventsCRUD interface.
type MockHistoryEventsCRUD struct {
	ctrl     *gomock.Controller
	recorder *MockHistoryEventsCRUDMockRecorder
}

// MockHistoryEventsCRUDMockRecorder is the mock recorder for MockHistoryEventsCRUD.
type MockHistoryEventsCRUDMockRecorder struct {
	mock *MockHistoryEventsCRUD
}

// NewMockHistoryEventsCRUD creates a new mock instance.
func NewMockHistoryEventsCRUD(ctrl *gomock.Controller) *MockHistoryEventsCRUD {
	mock := &MockHistoryEventsCRUD{ctrl: ctrl}
	mock.recorder = &MockHistoryEventsCRUDMockRecorder{mock}
	return mock
}

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

// DeleteFromHistoryTreeAndNode mocks base method.
func (m *MockHistoryEventsCRUD) DeleteFromHistoryTreeAndNode(ctx context.Context, treeFilter *HistoryTreeFilter, nodeFilters []*HistoryNodeFilter) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromHistoryTreeAndNode", ctx, treeFilter, nodeFilters)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteFromHistoryTreeAndNode indicates an expected call of DeleteFromHistoryTreeAndNode.
func (mr *MockHistoryEventsCRUDMockRecorder) DeleteFromHistoryTreeAndNode(ctx, treeFilter, nodeFilters interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFromHistoryTreeAndNode", reflect.TypeOf((*MockHistoryEventsCRUD)(nil).DeleteFromHistoryTreeAndNode), ctx, treeFilter, nodeFilters)
}

// InsertIntoHistoryTreeAndNode mocks base method.
func (m *MockHistoryEventsCRUD) InsertIntoHistoryTreeAndNode(ctx context.Context, treeRow *HistoryTreeRow, nodeRow *HistoryNodeRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoHistoryTreeAndNode", ctx, treeRow, nodeRow)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertIntoHistoryTreeAndNode indicates an expected call of InsertIntoHistoryTreeAndNode.
func (mr *MockHistoryEventsCRUDMockRecorder) InsertIntoHistoryTreeAndNode(ctx, treeRow, nodeRow interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertIntoHistoryTreeAndNode", reflect.TypeOf((*MockHistoryEventsCRUD)(nil).InsertIntoHistoryTreeAndNode), ctx, treeRow, nodeRow)
}

// SelectAllHistoryTrees mocks base method.
func (m *MockHistoryEventsCRUD) SelectAllHistoryTrees(ctx context.Context, nextPageToken []byte, pageSize int) ([]*HistoryTreeRow, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectAllHistoryTrees", ctx, nextPageToken, pageSize)
	ret0, _ := ret[0].([]*HistoryTreeRow)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectAllHistoryTrees indicates an expected call of SelectAllHistoryTrees.
func (mr *MockHistoryEventsCRUDMockRecorder) SelectAllHistoryTrees(ctx, nextPageToken, pageSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAllHistoryTrees", reflect.TypeOf((*MockHistoryEventsCRUD)(nil).SelectAllHistoryTrees), ctx, nextPageToken, pageSize)
}

// SelectFromHistoryNode mocks base method.
func (m *MockHistoryEventsCRUD) SelectFromHistoryNode(ctx context.Context, filter *HistoryNodeFilter) ([]*HistoryNodeRow, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectFromHistoryNode", ctx, filter)
	ret0, _ := ret[0].([]*HistoryNodeRow)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// SelectFromHistoryTree mocks base method.
func (m *MockHistoryEventsCRUD) SelectFromHistoryTree(ctx context.Context, filter *HistoryTreeFilter) ([]*HistoryTreeRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectFromHistoryTree", ctx, filter)
	ret0, _ := ret[0].([]*HistoryTreeRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockMessageQueueCRUD is a mock of MessageQueueCRUD interface.
type MockMessageQueueCRUD struct {
	ctrl     *gomock.Controller
	recorder *MockMessageQueueCRUDMockRecorder
}

// MockMessageQueueCRUDMockRecorder is the mock recorder for MockMessageQueueCRUD.
type MockMessageQueueCRUDMockRecorder struct {
	mock *MockMessageQueueCRUD
}

// NewMockMessageQueueCRUD creates a new mock instance.
func NewMockMessageQueueCRUD(ctrl *gomock.Controller) *MockMessageQueueCRUD {
	mock := &MockMessageQueueCRUD{ctrl: ctrl}
	mock.recorder = &MockMessageQueueCRUDMockRecorder{mock}
	return mock
}

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

// DeleteMessage mocks base method.
func (m *MockMessageQueueCRUD) DeleteMessage(ctx context.Context, queueType persistence.QueueType, messageID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessage", ctx, queueType, messageID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMessage indicates an expected call of DeleteMessage.
func (mr *MockMessageQueueCRUDMockRecorder) DeleteMessage(ctx, queueType, messageID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessage", reflect.TypeOf((*MockMessageQueueCRUD)(nil).DeleteMessage), ctx, queueType, messageID)
}

// DeleteMessagesBefore mocks base method.
func (m *MockMessageQueueCRUD) DeleteMessagesBefore(ctx context.Context, queueType persistence.QueueType, exclusiveBeginMessageID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessagesBefore", ctx, queueType, exclusiveBeginMessageID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMessagesBefore indicates an expected call of DeleteMessagesBefore.
func (mr *MockMessageQueueCRUDMockRecorder) DeleteMessagesBefore(ctx, queueType, exclusiveBeginMessageID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessagesBefore", reflect.TypeOf((*MockMessageQueueCRUD)(nil).DeleteMessagesBefore), ctx, queueType, exclusiveBeginMessageID)
}

// DeleteMessagesInRange mocks base method.
func (m *MockMessageQueueCRUD) DeleteMessagesInRange(ctx context.Context, queueType persistence.QueueType, exclusiveBeginMessageID, inclusiveEndMessageID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessagesInRange", ctx, queueType, exclusiveBeginMessageID, inclusiveEndMessageID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMessagesInRange indicates an expected call of DeleteMessagesInRange.
func (mr *MockMessageQueueCRUDMockRecorder) DeleteMessagesInRange(ctx, queueType, exclusiveBeginMessageID, inclusiveEndMessageID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessagesInRange", reflect.TypeOf((*MockMessageQueueCRUD)(nil).DeleteMessagesInRange), ctx, queueType, exclusiveBeginMessageID, inclusiveEndMessageID)
}

// GetQueueSize mocks base method.
func (m *MockMessageQueueCRUD) GetQueueSize(ctx context.Context, queueType persistence.QueueType) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueueSize", ctx, queueType)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoQueue mocks base method.
func (m *MockMessageQueueCRUD) InsertIntoQueue(ctx context.Context, row *QueueMessageRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoQueue", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertQueueMetadata mocks base method.
func (m *MockMessageQueueCRUD) InsertQueueMetadata(ctx context.Context, queueType persistence.QueueType, version int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertQueueMetadata", ctx, queueType, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertQueueMetadata indicates an expected call of InsertQueueMetadata.
func (mr *MockMessageQueueCRUDMockRecorder) InsertQueueMetadata(ctx, queueType, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertQueueMetadata", reflect.TypeOf((*MockMessageQueueCRUD)(nil).InsertQueueMetadata), ctx, queueType, version)
}

// SelectLastEnqueuedMessageID mocks base method.
func (m *MockMessageQueueCRUD) SelectLastEnqueuedMessageID(ctx context.Context, queueType persistence.QueueType) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectLastEnqueuedMessageID", ctx, queueType)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectMessagesBetween mocks base method.
func (m *MockMessageQueueCRUD) SelectMessagesBetween(ctx context.Context, request SelectMessagesBetweenRequest) (*SelectMessagesBetweenResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectMessagesBetween", ctx, request)
	ret0, _ := ret[0].(*SelectMessagesBetweenResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectMessagesFrom mocks base method.
func (m *MockMessageQueueCRUD) SelectMessagesFrom(ctx context.Context, queueType persistence.QueueType, exclusiveBeginMessageID int64, maxRows int) ([]*QueueMessageRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectMessagesFrom", ctx, queueType, exclusiveBeginMessageID, maxRows)
	ret0, _ := ret[0].([]*QueueMessageRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectMessagesFrom indicates an expected call of SelectMessagesFrom.
func (mr *MockMessageQueueCRUDMockRecorder) SelectMessagesFrom(ctx, queueType, exclusiveBeginMessageID, maxRows interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectMessagesFrom", reflect.TypeOf((*MockMessageQueueCRUD)(nil).SelectMessagesFrom), ctx, queueType, exclusiveBeginMessageID, maxRows)
}

// SelectQueueMetadata mocks base method.
func (m *MockMessageQueueCRUD) SelectQueueMetadata(ctx context.Context, queueType persistence.QueueType) (*QueueMetadataRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectQueueMetadata", ctx, queueType)
	ret0, _ := ret[0].(*QueueMetadataRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateQueueMetadataCas mocks base method.
func (m *MockMessageQueueCRUD) UpdateQueueMetadataCas(ctx context.Context, row QueueMetadataRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateQueueMetadataCas", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockDomainCRUD is a mock of DomainCRUD interface.
type MockDomainCRUD struct {
	ctrl     *gomock.Controller
	recorder *MockDomainCRUDMockRecorder
}

// MockDomainCRUDMockRecorder is the mock recorder for MockDomainCRUD.
type MockDomainCRUDMockRecorder struct {
	mock *MockDomainCRUD
}

// NewMockDomainCRUD creates a new mock instance.
func NewMockDomainCRUD(ctrl *gomock.Controller) *MockDomainCRUD {
	mock := &MockDomainCRUD{ctrl: ctrl}
	mock.recorder = &MockDomainCRUDMockRecorder{mock}
	return mock
}

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

// DeleteDomain mocks base method.
func (m *MockDomainCRUD) DeleteDomain(ctx context.Context, domainID, domainName *string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDomain", ctx, domainID, domainName)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDomain indicates an expected call of DeleteDomain.
func (mr *MockDomainCRUDMockRecorder) DeleteDomain(ctx, domainID, domainName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDomain", reflect.TypeOf((*MockDomainCRUD)(nil).DeleteDomain), ctx, domainID, domainName)
}

// InsertDomain mocks base method.
func (m *MockDomainCRUD) InsertDomain(ctx context.Context, row *DomainRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertDomain", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SelectAllDomains mocks base method.
func (m *MockDomainCRUD) SelectAllDomains(ctx context.Context, pageSize int, pageToken []byte) ([]*DomainRow, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectAllDomains", ctx, pageSize, pageToken)
	ret0, _ := ret[0].([]*DomainRow)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectAllDomains indicates an expected call of SelectAllDomains.
func (mr *MockDomainCRUDMockRecorder) SelectAllDomains(ctx, pageSize, pageToken interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAllDomains", reflect.TypeOf((*MockDomainCRUD)(nil).SelectAllDomains), ctx, pageSize, pageToken)
}

// SelectDomain mocks base method.
func (m *MockDomainCRUD) SelectDomain(ctx context.Context, domainID, domainName *string) (*DomainRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectDomain", ctx, domainID, domainName)
	ret0, _ := ret[0].(*DomainRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectDomain indicates an expected call of SelectDomain.
func (mr *MockDomainCRUDMockRecorder) SelectDomain(ctx, domainID, domainName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectDomain", reflect.TypeOf((*MockDomainCRUD)(nil).SelectDomain), ctx, domainID, domainName)
}

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

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

// UpdateDomain mocks base method.
func (m *MockDomainCRUD) UpdateDomain(ctx context.Context, row *DomainRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDomain", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockShardCRUD is a mock of ShardCRUD interface.
type MockShardCRUD struct {
	ctrl     *gomock.Controller
	recorder *MockShardCRUDMockRecorder
}

// MockShardCRUDMockRecorder is the mock recorder for MockShardCRUD.
type MockShardCRUDMockRecorder struct {
	mock *MockShardCRUD
}

// NewMockShardCRUD creates a new mock instance.
func NewMockShardCRUD(ctrl *gomock.Controller) *MockShardCRUD {
	mock := &MockShardCRUD{ctrl: ctrl}
	mock.recorder = &MockShardCRUDMockRecorder{mock}
	return mock
}

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

// InsertShard mocks base method.
func (m *MockShardCRUD) InsertShard(ctx context.Context, row *ShardRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertShard", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SelectShard mocks base method.
func (m *MockShardCRUD) SelectShard(ctx context.Context, shardID int, currentClusterName string) (int64, *ShardRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectShard", ctx, shardID, currentClusterName)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(*ShardRow)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectShard indicates an expected call of SelectShard.
func (mr *MockShardCRUDMockRecorder) SelectShard(ctx, shardID, currentClusterName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectShard", reflect.TypeOf((*MockShardCRUD)(nil).SelectShard), ctx, shardID, currentClusterName)
}

// UpdateRangeID mocks base method.
func (m *MockShardCRUD) UpdateRangeID(ctx context.Context, shardID int, rangeID, previousRangeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRangeID", ctx, shardID, rangeID, previousRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateRangeID indicates an expected call of UpdateRangeID.
func (mr *MockShardCRUDMockRecorder) UpdateRangeID(ctx, shardID, rangeID, previousRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRangeID", reflect.TypeOf((*MockShardCRUD)(nil).UpdateRangeID), ctx, shardID, rangeID, previousRangeID)
}

// UpdateShard mocks base method.
func (m *MockShardCRUD) UpdateShard(ctx context.Context, row *ShardRow, previousRangeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateShard", ctx, row, previousRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateShard indicates an expected call of UpdateShard.
func (mr *MockShardCRUDMockRecorder) UpdateShard(ctx, row, previousRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateShard", reflect.TypeOf((*MockShardCRUD)(nil).UpdateShard), ctx, row, previousRangeID)
}

// MockVisibilityCRUD is a mock of VisibilityCRUD interface.
type MockVisibilityCRUD struct {
	ctrl     *gomock.Controller
	recorder *MockVisibilityCRUDMockRecorder
}

// MockVisibilityCRUDMockRecorder is the mock recorder for MockVisibilityCRUD.
type MockVisibilityCRUDMockRecorder struct {
	mock *MockVisibilityCRUD
}

// NewMockVisibilityCRUD creates a new mock instance.
func NewMockVisibilityCRUD(ctrl *gomock.Controller) *MockVisibilityCRUD {
	mock := &MockVisibilityCRUD{ctrl: ctrl}
	mock.recorder = &MockVisibilityCRUDMockRecorder{mock}
	return mock
}

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

// DeleteVisibility mocks base method.
func (m *MockVisibilityCRUD) DeleteVisibility(ctx context.Context, domainID, workflowID, runID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVisibility", ctx, domainID, workflowID, runID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteVisibility indicates an expected call of DeleteVisibility.
func (mr *MockVisibilityCRUDMockRecorder) DeleteVisibility(ctx, domainID, workflowID, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVisibility", reflect.TypeOf((*MockVisibilityCRUD)(nil).DeleteVisibility), ctx, domainID, workflowID, runID)
}

// InsertVisibility mocks base method.
func (m *MockVisibilityCRUD) InsertVisibility(ctx context.Context, ttlSeconds int64, row *VisibilityRowForInsert) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertVisibility", ctx, ttlSeconds, row)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertVisibility indicates an expected call of InsertVisibility.
func (mr *MockVisibilityCRUDMockRecorder) InsertVisibility(ctx, ttlSeconds, row interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertVisibility", reflect.TypeOf((*MockVisibilityCRUD)(nil).InsertVisibility), ctx, ttlSeconds, row)
}

// SelectOneClosedWorkflow mocks base method.
func (m *MockVisibilityCRUD) SelectOneClosedWorkflow(ctx context.Context, domainID, workflowID, runID string) (*VisibilityRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectOneClosedWorkflow", ctx, domainID, workflowID, runID)
	ret0, _ := ret[0].(*VisibilityRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectOneClosedWorkflow indicates an expected call of SelectOneClosedWorkflow.
func (mr *MockVisibilityCRUDMockRecorder) SelectOneClosedWorkflow(ctx, domainID, workflowID, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectOneClosedWorkflow", reflect.TypeOf((*MockVisibilityCRUD)(nil).SelectOneClosedWorkflow), ctx, domainID, workflowID, runID)
}

// SelectVisibility mocks base method.
func (m *MockVisibilityCRUD) SelectVisibility(ctx context.Context, filter *VisibilityFilter) (*SelectVisibilityResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectVisibility", ctx, filter)
	ret0, _ := ret[0].(*SelectVisibilityResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateVisibility mocks base method.
func (m *MockVisibilityCRUD) UpdateVisibility(ctx context.Context, ttlSeconds int64, row *VisibilityRowForUpdate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateVisibility", ctx, ttlSeconds, row)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateVisibility indicates an expected call of UpdateVisibility.
func (mr *MockVisibilityCRUDMockRecorder) UpdateVisibility(ctx, ttlSeconds, row interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateVisibility", reflect.TypeOf((*MockVisibilityCRUD)(nil).UpdateVisibility), ctx, ttlSeconds, row)
}

// MockTaskCRUD is a mock of TaskCRUD interface.
type MockTaskCRUD struct {
	ctrl     *gomock.Controller
	recorder *MockTaskCRUDMockRecorder
}

// MockTaskCRUDMockRecorder is the mock recorder for MockTaskCRUD.
type MockTaskCRUDMockRecorder struct {
	mock *MockTaskCRUD
}

// NewMockTaskCRUD creates a new mock instance.
func NewMockTaskCRUD(ctrl *gomock.Controller) *MockTaskCRUD {
	mock := &MockTaskCRUD{ctrl: ctrl}
	mock.recorder = &MockTaskCRUDMockRecorder{mock}
	return mock
}

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

// DeleteTaskList mocks base method.
func (m *MockTaskCRUD) DeleteTaskList(ctx context.Context, filter *TaskListFilter, previousRangeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTaskList", ctx, filter, previousRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTaskList indicates an expected call of DeleteTaskList.
func (mr *MockTaskCRUDMockRecorder) DeleteTaskList(ctx, filter, previousRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTaskList", reflect.TypeOf((*MockTaskCRUD)(nil).DeleteTaskList), ctx, filter, previousRangeID)
}

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

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

// InsertTaskList mocks base method.
func (m *MockTaskCRUD) InsertTaskList(ctx context.Context, row *TaskListRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTaskList", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertTasks mocks base method.
func (m *MockTaskCRUD) InsertTasks(ctx context.Context, tasksToInsert []*TaskRowForInsert, tasklistCondition *TaskListRow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTasks", ctx, tasksToInsert, tasklistCondition)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertTasks indicates an expected call of InsertTasks.
func (mr *MockTaskCRUDMockRecorder) InsertTasks(ctx, tasksToInsert, tasklistCondition interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertTasks", reflect.TypeOf((*MockTaskCRUD)(nil).InsertTasks), ctx, tasksToInsert, tasklistCondition)
}

// ListTaskList mocks base method.
func (m *MockTaskCRUD) ListTaskList(ctx context.Context, pageSize int, nextPageToken []byte) (*ListTaskListResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTaskList", ctx, pageSize, nextPageToken)
	ret0, _ := ret[0].(*ListTaskListResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTaskList indicates an expected call of ListTaskList.
func (mr *MockTaskCRUDMockRecorder) ListTaskList(ctx, pageSize, nextPageToken interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskList", reflect.TypeOf((*MockTaskCRUD)(nil).ListTaskList), ctx, pageSize, nextPageToken)
}

// RangeDeleteTasks mocks base method.
func (m *MockTaskCRUD) RangeDeleteTasks(ctx context.Context, filter *TasksFilter) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteTasks", ctx, filter)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectTaskList mocks base method.
func (m *MockTaskCRUD) SelectTaskList(ctx context.Context, filter *TaskListFilter) (*TaskListRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectTaskList", ctx, filter)
	ret0, _ := ret[0].(*TaskListRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectTasks mocks base method.
func (m *MockTaskCRUD) SelectTasks(ctx context.Context, filter *TasksFilter) ([]*TaskRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectTasks", ctx, filter)
	ret0, _ := ret[0].([]*TaskRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTaskList mocks base method.
func (m *MockTaskCRUD) UpdateTaskList(ctx context.Context, row *TaskListRow, previousRangeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskList", ctx, row, previousRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTaskList indicates an expected call of UpdateTaskList.
func (mr *MockTaskCRUDMockRecorder) UpdateTaskList(ctx, row, previousRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskList", reflect.TypeOf((*MockTaskCRUD)(nil).UpdateTaskList), ctx, row, previousRangeID)
}

// UpdateTaskListWithTTL mocks base method.
func (m *MockTaskCRUD) UpdateTaskListWithTTL(ctx context.Context, ttlSeconds int64, row *TaskListRow, previousRangeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskListWithTTL", ctx, ttlSeconds, row, previousRangeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTaskListWithTTL indicates an expected call of UpdateTaskListWithTTL.
func (mr *MockTaskCRUDMockRecorder) UpdateTaskListWithTTL(ctx, ttlSeconds, row, previousRangeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskListWithTTL", reflect.TypeOf((*MockTaskCRUD)(nil).UpdateTaskListWithTTL), ctx, ttlSeconds, row, previousRangeID)
}

// MockWorkflowCRUD is a mock of WorkflowCRUD interface.
type MockWorkflowCRUD struct {
	ctrl     *gomock.Controller
	recorder *MockWorkflowCRUDMockRecorder
}

// MockWorkflowCRUDMockRecorder is the mock recorder for MockWorkflowCRUD.
type MockWorkflowCRUDMockRecorder struct {
	mock *MockWorkflowCRUD
}

// NewMockWorkflowCRUD creates a new mock instance.
func NewMockWorkflowCRUD(ctrl *gomock.Controller) *MockWorkflowCRUD {
	mock := &MockWorkflowCRUD{ctrl: ctrl}
	mock.recorder = &MockWorkflowCRUDMockRecorder{mock}
	return mock
}

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

// DeleteCrossClusterTask mocks base method.
func (m *MockWorkflowCRUD) DeleteCrossClusterTask(ctx context.Context, shardID int, targetCluster string, taskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCrossClusterTask", ctx, shardID, targetCluster, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCrossClusterTask indicates an expected call of DeleteCrossClusterTask.
func (mr *MockWorkflowCRUDMockRecorder) DeleteCrossClusterTask(ctx, shardID, targetCluster, taskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCrossClusterTask", reflect.TypeOf((*MockWorkflowCRUD)(nil).DeleteCrossClusterTask), ctx, shardID, targetCluster, taskID)
}

// DeleteCurrentWorkflow mocks base method.
func (m *MockWorkflowCRUD) DeleteCurrentWorkflow(ctx context.Context, shardID int, domainID, workflowID, currentRunIDCondition string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCurrentWorkflow", ctx, shardID, domainID, workflowID, currentRunIDCondition)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCurrentWorkflow indicates an expected call of DeleteCurrentWorkflow.
func (mr *MockWorkflowCRUDMockRecorder) DeleteCurrentWorkflow(ctx, shardID, domainID, workflowID, currentRunIDCondition interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCurrentWorkflow", reflect.TypeOf((*MockWorkflowCRUD)(nil).DeleteCurrentWorkflow), ctx, shardID, domainID, workflowID, currentRunIDCondition)
}

// DeleteReplicationDLQTask mocks base method.
func (m *MockWorkflowCRUD) DeleteReplicationDLQTask(ctx context.Context, shardID int, sourceCluster string, taskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReplicationDLQTask", ctx, shardID, sourceCluster, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteReplicationDLQTask indicates an expected call of DeleteReplicationDLQTask.
func (mr *MockWorkflowCRUDMockRecorder) DeleteReplicationDLQTask(ctx, shardID, sourceCluster, taskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationDLQTask", reflect.TypeOf((*MockWorkflowCRUD)(nil).DeleteReplicationDLQTask), ctx, shardID, sourceCluster, taskID)
}

// DeleteReplicationTask mocks base method.
func (m *MockWorkflowCRUD) DeleteReplicationTask(ctx context.Context, shardID int, taskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReplicationTask", ctx, shardID, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteReplicationTask indicates an expected call of DeleteReplicationTask.
func (mr *MockWorkflowCRUDMockRecorder) DeleteReplicationTask(ctx, shardID, taskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationTask", reflect.TypeOf((*MockWorkflowCRUD)(nil).DeleteReplicationTask), ctx, shardID, taskID)
}

// DeleteTimerTask mocks base method.
func (m *MockWorkflowCRUD) DeleteTimerTask(ctx context.Context, shardID int, taskID int64, visibilityTimestamp time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTimerTask", ctx, shardID, taskID, visibilityTimestamp)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTimerTask indicates an expected call of DeleteTimerTask.
func (mr *MockWorkflowCRUDMockRecorder) DeleteTimerTask(ctx, shardID, taskID, visibilityTimestamp interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTimerTask", reflect.TypeOf((*MockWorkflowCRUD)(nil).DeleteTimerTask), ctx, shardID, taskID, visibilityTimestamp)
}

// DeleteTransferTask mocks base method.
func (m *MockWorkflowCRUD) DeleteTransferTask(ctx context.Context, shardID int, taskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransferTask", ctx, shardID, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTransferTask indicates an expected call of DeleteTransferTask.
func (mr *MockWorkflowCRUDMockRecorder) DeleteTransferTask(ctx, shardID, taskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransferTask", reflect.TypeOf((*MockWorkflowCRUD)(nil).DeleteTransferTask), ctx, shardID, taskID)
}

// DeleteWorkflowExecution mocks base method.
func (m *MockWorkflowCRUD) DeleteWorkflowExecution(ctx context.Context, shardID int, domainID, workflowID, runID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkflowExecution", ctx, shardID, domainID, workflowID, runID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteWorkflowExecution indicates an expected call of DeleteWorkflowExecution.
func (mr *MockWorkflowCRUDMockRecorder) DeleteWorkflowExecution(ctx, shardID, domainID, workflowID, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkflowExecution", reflect.TypeOf((*MockWorkflowCRUD)(nil).DeleteWorkflowExecution), ctx, shardID, domainID, workflowID, runID)
}

// InsertReplicationDLQTask mocks base method.
func (m *MockWorkflowCRUD) InsertReplicationDLQTask(ctx context.Context, shardID int, sourceCluster string, task ReplicationTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertReplicationDLQTask", ctx, shardID, sourceCluster, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertReplicationDLQTask indicates an expected call of InsertReplicationDLQTask.
func (mr *MockWorkflowCRUDMockRecorder) InsertReplicationDLQTask(ctx, shardID, sourceCluster, task interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertReplicationDLQTask", reflect.TypeOf((*MockWorkflowCRUD)(nil).InsertReplicationDLQTask), ctx, shardID, sourceCluster, task)
}

// InsertReplicationTask mocks base method.
func (m *MockWorkflowCRUD) InsertReplicationTask(ctx context.Context, tasks []*ReplicationTask, condition ShardCondition) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertReplicationTask", ctx, tasks, condition)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertReplicationTask indicates an expected call of InsertReplicationTask.
func (mr *MockWorkflowCRUDMockRecorder) InsertReplicationTask(ctx, tasks, condition interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertReplicationTask", reflect.TypeOf((*MockWorkflowCRUD)(nil).InsertReplicationTask), ctx, tasks, condition)
}

// InsertWorkflowExecutionWithTasks mocks base method.
func (m *MockWorkflowCRUD) InsertWorkflowExecutionWithTasks(ctx context.Context, currentWorkflowRequest *CurrentWorkflowWriteRequest, execution *WorkflowExecutionRequest, transferTasks []*TransferTask, crossClusterTasks []*CrossClusterTask, replicationTasks []*ReplicationTask, timerTasks []*TimerTask, shardCondition *ShardCondition) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkflowExecutionWithTasks", ctx, currentWorkflowRequest, execution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertWorkflowExecutionWithTasks indicates an expected call of InsertWorkflowExecutionWithTasks.
func (mr *MockWorkflowCRUDMockRecorder) InsertWorkflowExecutionWithTasks(ctx, currentWorkflowRequest, execution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkflowExecutionWithTasks", reflect.TypeOf((*MockWorkflowCRUD)(nil).InsertWorkflowExecutionWithTasks), ctx, currentWorkflowRequest, execution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition)
}

// IsWorkflowExecutionExists mocks base method.
func (m *MockWorkflowCRUD) IsWorkflowExecutionExists(ctx context.Context, shardID int, domainID, workflowID, runID string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsWorkflowExecutionExists", ctx, shardID, domainID, workflowID, runID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsWorkflowExecutionExists indicates an expected call of IsWorkflowExecutionExists.
func (mr *MockWorkflowCRUDMockRecorder) IsWorkflowExecutionExists(ctx, shardID, domainID, workflowID, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsWorkflowExecutionExists", reflect.TypeOf((*MockWorkflowCRUD)(nil).IsWorkflowExecutionExists), ctx, shardID, domainID, workflowID, runID)
}

// RangeDeleteCrossClusterTasks mocks base method.
func (m *MockWorkflowCRUD) RangeDeleteCrossClusterTasks(ctx context.Context, shardID int, targetCluster string, exclusiveBeginTaskID, inclusiveEndTaskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteCrossClusterTasks", ctx, shardID, targetCluster, exclusiveBeginTaskID, inclusiveEndTaskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteCrossClusterTasks indicates an expected call of RangeDeleteCrossClusterTasks.
func (mr *MockWorkflowCRUDMockRecorder) RangeDeleteCrossClusterTasks(ctx, shardID, targetCluster, exclusiveBeginTaskID, inclusiveEndTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteCrossClusterTasks", reflect.TypeOf((*MockWorkflowCRUD)(nil).RangeDeleteCrossClusterTasks), ctx, shardID, targetCluster, exclusiveBeginTaskID, inclusiveEndTaskID)
}

// RangeDeleteReplicationDLQTasks mocks base method.
func (m *MockWorkflowCRUD) RangeDeleteReplicationDLQTasks(ctx context.Context, shardID int, sourceCluster string, exclusiveBeginTaskID, inclusiveEndTaskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteReplicationDLQTasks", ctx, shardID, sourceCluster, exclusiveBeginTaskID, inclusiveEndTaskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteReplicationDLQTasks indicates an expected call of RangeDeleteReplicationDLQTasks.
func (mr *MockWorkflowCRUDMockRecorder) RangeDeleteReplicationDLQTasks(ctx, shardID, sourceCluster, exclusiveBeginTaskID, inclusiveEndTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteReplicationDLQTasks", reflect.TypeOf((*MockWorkflowCRUD)(nil).RangeDeleteReplicationDLQTasks), ctx, shardID, sourceCluster, exclusiveBeginTaskID, inclusiveEndTaskID)
}

// RangeDeleteReplicationTasks mocks base method.
func (m *MockWorkflowCRUD) RangeDeleteReplicationTasks(ctx context.Context, shardID int, inclusiveEndTaskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteReplicationTasks", ctx, shardID, inclusiveEndTaskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteReplicationTasks indicates an expected call of RangeDeleteReplicationTasks.
func (mr *MockWorkflowCRUDMockRecorder) RangeDeleteReplicationTasks(ctx, shardID, inclusiveEndTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteReplicationTasks", reflect.TypeOf((*MockWorkflowCRUD)(nil).RangeDeleteReplicationTasks), ctx, shardID, inclusiveEndTaskID)
}

// RangeDeleteTimerTasks mocks base method.
func (m *MockWorkflowCRUD) RangeDeleteTimerTasks(ctx context.Context, shardID int, inclusiveMinTime, exclusiveMaxTime time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteTimerTasks", ctx, shardID, inclusiveMinTime, exclusiveMaxTime)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteTimerTasks indicates an expected call of RangeDeleteTimerTasks.
func (mr *MockWorkflowCRUDMockRecorder) RangeDeleteTimerTasks(ctx, shardID, inclusiveMinTime, exclusiveMaxTime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteTimerTasks", reflect.TypeOf((*MockWorkflowCRUD)(nil).RangeDeleteTimerTasks), ctx, shardID, inclusiveMinTime, exclusiveMaxTime)
}

// RangeDeleteTransferTasks mocks base method.
func (m *MockWorkflowCRUD) RangeDeleteTransferTasks(ctx context.Context, shardID int, exclusiveBeginTaskID, inclusiveEndTaskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteTransferTasks", ctx, shardID, exclusiveBeginTaskID, inclusiveEndTaskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteTransferTasks indicates an expected call of RangeDeleteTransferTasks.
func (mr *MockWorkflowCRUDMockRecorder) RangeDeleteTransferTasks(ctx, shardID, exclusiveBeginTaskID, inclusiveEndTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteTransferTasks", reflect.TypeOf((*MockWorkflowCRUD)(nil).RangeDeleteTransferTasks), ctx, shardID, exclusiveBeginTaskID, inclusiveEndTaskID)
}

// SelectAllCurrentWorkflows mocks base method.
func (m *MockWorkflowCRUD) SelectAllCurrentWorkflows(ctx context.Context, shardID int, pageToken []byte, pageSize int) ([]*persistence.CurrentWorkflowExecution, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectAllCurrentWorkflows", ctx, shardID, pageToken, pageSize)
	ret0, _ := ret[0].([]*persistence.CurrentWorkflowExecution)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectAllCurrentWorkflows indicates an expected call of SelectAllCurrentWorkflows.
func (mr *MockWorkflowCRUDMockRecorder) SelectAllCurrentWorkflows(ctx, shardID, pageToken, pageSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAllCurrentWorkflows", reflect.TypeOf((*MockWorkflowCRUD)(nil).SelectAllCurrentWorkflows), ctx, shardID, pageToken, pageSize)
}

// SelectAllWorkflowExecutions mocks base method.
func (m *MockWorkflowCRUD) SelectAllWorkflowExecutions(ctx context.Context, shardID int, pageToken []byte, pageSize int) ([]*persistence.InternalListConcreteExecutionsEntity, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectAllWorkflowExecutions", ctx, shardID, pageToken, pageSize)
	ret0, _ := ret[0].([]*persistence.InternalListConcreteExecutionsEntity)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectAllWorkflowExecutions indicates an expected call of SelectAllWorkflowExecutions.
func (mr *MockWorkflowCRUDMockRecorder) SelectAllWorkflowExecutions(ctx, shardID, pageToken, pageSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAllWorkflowExecutions", reflect.TypeOf((*MockWorkflowCRUD)(nil).SelectAllWorkflowExecutions), ctx, shardID, pageToken, pageSize)
}

// SelectCrossClusterTasksOrderByTaskID mocks base method.
func (m *MockWorkflowCRUD) SelectCrossClusterTasksOrderByTaskID(ctx context.Context, shardID, pageSize int, pageToken []byte, targetCluster string, exclusiveMinTaskID, inclusiveMaxTaskID int64) ([]*CrossClusterTask, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectCrossClusterTasksOrderByTaskID", ctx, shardID, pageSize, pageToken, targetCluster, exclusiveMinTaskID, inclusiveMaxTaskID)
	ret0, _ := ret[0].([]*CrossClusterTask)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectCrossClusterTasksOrderByTaskID indicates an expected call of SelectCrossClusterTasksOrderByTaskID.
func (mr *MockWorkflowCRUDMockRecorder) SelectCrossClusterTasksOrderByTaskID(ctx, shardID, pageSize, pageToken, targetCluster, exclusiveMinTaskID, inclusiveMaxTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectCrossClusterTasksOrderByTaskID", reflect.TypeOf((*MockWorkflowCRUD)(nil).SelectCrossClusterTasksOrderByTaskID), ctx, shardID, pageSize, pageToken, targetCluster, exclusiveMinTaskID, inclusiveMaxTaskID)
}

// SelectCurrentWorkflow mocks base method.
func (m *MockWorkflowCRUD) SelectCurrentWorkflow(ctx context.Context, shardID int, domainID, workflowID string) (*CurrentWorkflowRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectCurrentWorkflow", ctx, shardID, domainID, workflowID)
	ret0, _ := ret[0].(*CurrentWorkflowRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectCurrentWorkflow indicates an expected call of SelectCurrentWorkflow.
func (mr *MockWorkflowCRUDMockRecorder) SelectCurrentWorkflow(ctx, shardID, domainID, workflowID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectCurrentWorkflow", reflect.TypeOf((*MockWorkflowCRUD)(nil).SelectCurrentWorkflow), ctx, shardID, domainID, workflowID)
}

// SelectReplicationDLQTasksCount mocks base method.
func (m *MockWorkflowCRUD) SelectReplicationDLQTasksCount(ctx context.Context, shardID int, sourceCluster string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectReplicationDLQTasksCount", ctx, shardID, sourceCluster)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectReplicationDLQTasksCount indicates an expected call of SelectReplicationDLQTasksCount.
func (mr *MockWorkflowCRUDMockRecorder) SelectReplicationDLQTasksCount(ctx, shardID, sourceCluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectReplicationDLQTasksCount", reflect.TypeOf((*MockWorkflowCRUD)(nil).SelectReplicationDLQTasksCount), ctx, shardID, sourceCluster)
}

// SelectReplicationDLQTasksOrderByTaskID mocks base method.
func (m *MockWorkflowCRUD) SelectReplicationDLQTasksOrderByTaskID(ctx context.Context, shardID int, sourceCluster string, pageSize int, pageToken []byte, exclusiveMinTaskID, inclusiveMaxTaskID int64) ([]*ReplicationTask, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectReplicationDLQTasksOrderByTaskID", ctx, shardID, sourceCluster, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
	ret0, _ := ret[0].([]*ReplicationTask)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectReplicationDLQTasksOrderByTaskID indicates an expected call of SelectReplicationDLQTasksOrderByTaskID.
func (mr *MockWorkflowCRUDMockRecorder) SelectReplicationDLQTasksOrderByTaskID(ctx, shardID, sourceCluster, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectReplicationDLQTasksOrderByTaskID", reflect.TypeOf((*MockWorkflowCRUD)(nil).SelectReplicationDLQTasksOrderByTaskID), ctx, shardID, sourceCluster, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
}

// SelectReplicationTasksOrderByTaskID mocks base method.
func (m *MockWorkflowCRUD) SelectReplicationTasksOrderByTaskID(ctx context.Context, shardID, pageSize int, pageToken []byte, exclusiveMinTaskID, inclusiveMaxTaskID int64) ([]*ReplicationTask, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectReplicationTasksOrderByTaskID", ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
	ret0, _ := ret[0].([]*ReplicationTask)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectReplicationTasksOrderByTaskID indicates an expected call of SelectReplicationTasksOrderByTaskID.
func (mr *MockWorkflowCRUDMockRecorder) SelectReplicationTasksOrderByTaskID(ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectReplicationTasksOrderByTaskID", reflect.TypeOf((*MockWorkflowCRUD)(nil).SelectReplicationTasksOrderByTaskID), ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
}

// SelectTimerTasksOrderByVisibilityTime mocks base method.
func (m *MockWorkflowCRUD) SelectTimerTasksOrderByVisibilityTime(ctx context.Context, shardID, pageSize int, pageToken []byte, inclusiveMinTime, exclusiveMaxTime time.Time) ([]*TimerTask, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectTimerTasksOrderByVisibilityTime", ctx, shardID, pageSize, pageToken, inclusiveMinTime, exclusiveMaxTime)
	ret0, _ := ret[0].([]*TimerTask)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectTimerTasksOrderByVisibilityTime indicates an expected call of SelectTimerTasksOrderByVisibilityTime.
func (mr *MockWorkflowCRUDMockRecorder) SelectTimerTasksOrderByVisibilityTime(ctx, shardID, pageSize, pageToken, inclusiveMinTime, exclusiveMaxTime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectTimerTasksOrderByVisibilityTime", reflect.TypeOf((*MockWorkflowCRUD)(nil).SelectTimerTasksOrderByVisibilityTime), ctx, shardID, pageSize, pageToken, inclusiveMinTime, exclusiveMaxTime)
}

// SelectTransferTasksOrderByTaskID mocks base method.
func (m *MockWorkflowCRUD) SelectTransferTasksOrderByTaskID(ctx context.Context, shardID, pageSize int, pageToken []byte, exclusiveMinTaskID, inclusiveMaxTaskID int64) ([]*TransferTask, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectTransferTasksOrderByTaskID", ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
	ret0, _ := ret[0].([]*TransferTask)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectTransferTasksOrderByTaskID indicates an expected call of SelectTransferTasksOrderByTaskID.
func (mr *MockWorkflowCRUDMockRecorder) SelectTransferTasksOrderByTaskID(ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectTransferTasksOrderByTaskID", reflect.TypeOf((*MockWorkflowCRUD)(nil).SelectTransferTasksOrderByTaskID), ctx, shardID, pageSize, pageToken, exclusiveMinTaskID, inclusiveMaxTaskID)
}

// SelectWorkflowExecution mocks base method.
func (m *MockWorkflowCRUD) SelectWorkflowExecution(ctx context.Context, shardID int, domainID, workflowID, runID string) (*WorkflowExecution, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectWorkflowExecution", ctx, shardID, domainID, workflowID, runID)
	ret0, _ := ret[0].(*WorkflowExecution)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectWorkflowExecution indicates an expected call of SelectWorkflowExecution.
func (mr *MockWorkflowCRUDMockRecorder) SelectWorkflowExecution(ctx, shardID, domainID, workflowID, runID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectWorkflowExecution", reflect.TypeOf((*MockWorkflowCRUD)(nil).SelectWorkflowExecution), ctx, shardID, domainID, workflowID, runID)
}

// UpdateWorkflowExecutionWithTasks mocks base method.
func (m *MockWorkflowCRUD) UpdateWorkflowExecutionWithTasks(ctx context.Context, currentWorkflowRequest *CurrentWorkflowWriteRequest, mutatedExecution, insertedExecution, resetExecution *WorkflowExecutionRequest, transferTasks []*TransferTask, crossClusterTasks []*CrossClusterTask, replicationTasks []*ReplicationTask, timerTasks []*TimerTask, shardCondition *ShardCondition) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkflowExecutionWithTasks", ctx, currentWorkflowRequest, mutatedExecution, insertedExecution, resetExecution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkflowExecutionWithTasks indicates an expected call of UpdateWorkflowExecutionWithTasks.
func (mr *MockWorkflowCRUDMockRecorder) UpdateWorkflowExecutionWithTasks(ctx, currentWorkflowRequest, mutatedExecution, insertedExecution, resetExecution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkflowExecutionWithTasks", reflect.TypeOf((*MockWorkflowCRUD)(nil).UpdateWorkflowExecutionWithTasks), ctx, currentWorkflowRequest, mutatedExecution, insertedExecution, resetExecution, transferTasks, crossClusterTasks, replicationTasks, timerTasks, shardCondition)
}

// MockConfigStoreCRUD is a mock of ConfigStoreCRUD interface.
type MockConfigStoreCRUD struct {
	ctrl     *gomock.Controller
	recorder *MockConfigStoreCRUDMockRecorder
}

// MockConfigStoreCRUDMockRecorder is the mock recorder for MockConfigStoreCRUD.
type MockConfigStoreCRUDMockRecorder struct {
	mock *MockConfigStoreCRUD
}

// NewMockConfigStoreCRUD creates a new mock instance.
func NewMockConfigStoreCRUD(ctrl *gomock.Controller) *MockConfigStoreCRUD {
	mock := &MockConfigStoreCRUD{ctrl: ctrl}
	mock.recorder = &MockConfigStoreCRUDMockRecorder{mock}
	return mock
}

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

// InsertConfig mocks base method.
func (m *MockConfigStoreCRUD) InsertConfig(ctx context.Context, row *persistence.InternalConfigStoreEntry) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertConfig", ctx, row)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SelectLatestConfig mocks base method.
func (m *MockConfigStoreCRUD) SelectLatestConfig(ctx context.Context, rowType int) (*persistence.InternalConfigStoreEntry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectLatestConfig", ctx, rowType)
	ret0, _ := ret[0].(*persistence.InternalConfigStoreEntry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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