common/persistence/sql/sqlplugin/interface_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 sqlplugin is a generated GoMock package.
package sqlplugin

import (
	context "context"
	sql "database/sql"
	reflect "reflect"
	time "time"

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

	config "github.com/uber/cadence/common/config"
	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.SQL) (AdminDB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAdminDB", cfg)
	ret0, _ := ret[0].(AdminDB)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// 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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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)
}

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

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

// 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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MaxAllowedTTL mocks base method.
func (m *MocktableCRUD) MaxAllowedTTL() (*time.Duration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MaxAllowedTTL")
	ret0, _ := ret[0].(*time.Duration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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)
}

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

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

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

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

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

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

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

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

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

// 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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockadminCRUD is a mock of adminCRUD interface.
type MockadminCRUD struct {
	ctrl     *gomock.Controller
	recorder *MockadminCRUDMockRecorder
}

// MockadminCRUDMockRecorder is the mock recorder for MockadminCRUD.
type MockadminCRUDMockRecorder struct {
	mock *MockadminCRUD
}

// NewMockadminCRUD creates a new mock instance.
func NewMockadminCRUD(ctrl *gomock.Controller) *MockadminCRUD {
	mock := &MockadminCRUD{ctrl: ctrl}
	mock.recorder = &MockadminCRUDMockRecorder{mock}
	return mock
}

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

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

// CreateDatabase indicates an expected call of CreateDatabase.
func (mr *MockadminCRUDMockRecorder) CreateDatabase(database interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDatabase", reflect.TypeOf((*MockadminCRUD)(nil).CreateDatabase), database)
}

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

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

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

// DropAllTables indicates an expected call of DropAllTables.
func (mr *MockadminCRUDMockRecorder) DropAllTables(database interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropAllTables", reflect.TypeOf((*MockadminCRUD)(nil).DropAllTables), database)
}

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

// DropDatabase indicates an expected call of DropDatabase.
func (mr *MockadminCRUDMockRecorder) DropDatabase(database interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropDatabase", reflect.TypeOf((*MockadminCRUD)(nil).DropDatabase), database)
}

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

// DropTable indicates an expected call of DropTable.
func (mr *MockadminCRUDMockRecorder) DropTable(table interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropTable", reflect.TypeOf((*MockadminCRUD)(nil).DropTable), table)
}

// ExecSchemaOperationQuery mocks base method.
func (m *MockadminCRUD) ExecSchemaOperationQuery(ctx context.Context, stmt string, args ...interface{}) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, stmt}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExecSchemaOperationQuery", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ExecSchemaOperationQuery indicates an expected call of ExecSchemaOperationQuery.
func (mr *MockadminCRUDMockRecorder) ExecSchemaOperationQuery(ctx, stmt interface{}, args ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, stmt}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecSchemaOperationQuery", reflect.TypeOf((*MockadminCRUD)(nil).ExecSchemaOperationQuery), varargs...)
}

// ListTables mocks base method.
func (m *MockadminCRUD) ListTables(database string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTables", database)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTables indicates an expected call of ListTables.
func (mr *MockadminCRUDMockRecorder) ListTables(database interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTables", reflect.TypeOf((*MockadminCRUD)(nil).ListTables), database)
}

// ReadSchemaVersion mocks base method.
func (m *MockadminCRUD) ReadSchemaVersion(database string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadSchemaVersion", database)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadSchemaVersion indicates an expected call of ReadSchemaVersion.
func (mr *MockadminCRUDMockRecorder) ReadSchemaVersion(database interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadSchemaVersion", reflect.TypeOf((*MockadminCRUD)(nil).ReadSchemaVersion), database)
}

// UpdateSchemaVersion mocks base method.
func (m *MockadminCRUD) UpdateSchemaVersion(database, newVersion, minCompatibleVersion string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSchemaVersion", database, newVersion, minCompatibleVersion)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateSchemaVersion indicates an expected call of UpdateSchemaVersion.
func (mr *MockadminCRUDMockRecorder) UpdateSchemaVersion(database, newVersion, minCompatibleVersion interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSchemaVersion", reflect.TypeOf((*MockadminCRUD)(nil).UpdateSchemaVersion), database, newVersion, minCompatibleVersion)
}

// WriteSchemaUpdateLog mocks base method.
func (m *MockadminCRUD) WriteSchemaUpdateLog(oldVersion, newVersion, manifestMD5, desc string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteSchemaUpdateLog", oldVersion, newVersion, manifestMD5, desc)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteSchemaUpdateLog indicates an expected call of WriteSchemaUpdateLog.
func (mr *MockadminCRUDMockRecorder) WriteSchemaUpdateLog(oldVersion, newVersion, manifestMD5, desc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteSchemaUpdateLog", reflect.TypeOf((*MockadminCRUD)(nil).WriteSchemaUpdateLog), oldVersion, newVersion, manifestMD5, desc)
}

// MockTx is a mock of Tx interface.
type MockTx struct {
	ctrl     *gomock.Controller
	recorder *MockTxMockRecorder
}

// MockTxMockRecorder is the mock recorder for MockTx.
type MockTxMockRecorder struct {
	mock *MockTx
}

// NewMockTx creates a new mock instance.
func NewMockTx(ctrl *gomock.Controller) *MockTx {
	mock := &MockTx{ctrl: ctrl}
	mock.recorder = &MockTxMockRecorder{mock}
	return mock
}

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

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

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

// DeleteFromActivityInfoMaps mocks base method.
func (m *MockTx) DeleteFromActivityInfoMaps(ctx context.Context, filter *ActivityInfoMapsFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromActivityInfoMaps", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFromBufferedEvents mocks base method.
func (m *MockTx) DeleteFromBufferedEvents(ctx context.Context, filter *BufferedEventsFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromBufferedEvents", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFromChildExecutionInfoMaps mocks base method.
func (m *MockTx) DeleteFromChildExecutionInfoMaps(ctx context.Context, filter *ChildExecutionInfoMapsFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromChildExecutionInfoMaps", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFromCrossClusterTasks mocks base method.
func (m *MockTx) DeleteFromCrossClusterTasks(ctx context.Context, filter *CrossClusterTasksFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromCrossClusterTasks", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFromCurrentExecutions mocks base method.
func (m *MockTx) DeleteFromCurrentExecutions(ctx context.Context, filter *CurrentExecutionsFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromCurrentExecutions", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFromDomain mocks base method.
func (m *MockTx) DeleteFromDomain(ctx context.Context, filter *DomainFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromDomain", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFromExecutions mocks base method.
func (m *MockTx) DeleteFromExecutions(ctx context.Context, filter *ExecutionsFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromExecutions", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFromHistoryNode mocks base method.
func (m *MockTx) DeleteFromHistoryNode(ctx context.Context, filter *HistoryNodeFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromHistoryNode", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// DeleteFromReplicationTasks mocks base method.
func (m *MockTx) DeleteFromReplicationTasks(ctx context.Context, filter *ReplicationTasksFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromReplicationTasks", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFromRequestCancelInfoMaps mocks base method.
func (m *MockTx) DeleteFromRequestCancelInfoMaps(ctx context.Context, filter *RequestCancelInfoMapsFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromRequestCancelInfoMaps", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFromSignalInfoMaps mocks base method.
func (m *MockTx) DeleteFromSignalInfoMaps(ctx context.Context, filter *SignalInfoMapsFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromSignalInfoMaps", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFromSignalsRequestedSets mocks base method.
func (m *MockTx) DeleteFromSignalsRequestedSets(ctx context.Context, filter *SignalsRequestedSetsFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromSignalsRequestedSets", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFromTaskLists mocks base method.
func (m *MockTx) DeleteFromTaskLists(ctx context.Context, filter *TaskListsFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromTaskLists", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// DeleteFromTimerInfoMaps mocks base method.
func (m *MockTx) DeleteFromTimerInfoMaps(ctx context.Context, filter *TimerInfoMapsFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromTimerInfoMaps", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFromTimerTasks mocks base method.
func (m *MockTx) DeleteFromTimerTasks(ctx context.Context, filter *TimerTasksFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromTimerTasks", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFromTransferTasks mocks base method.
func (m *MockTx) DeleteFromTransferTasks(ctx context.Context, filter *TransferTasksFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFromTransferTasks", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// DeleteMessageFromReplicationTasksDLQ mocks base method.
func (m *MockTx) DeleteMessageFromReplicationTasksDLQ(ctx context.Context, filter *ReplicationTasksDLQFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessageFromReplicationTasksDLQ", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

// GetMessagesBetween indicates an expected call of GetMessagesBetween.
func (mr *MockTxMockRecorder) GetMessagesBetween(ctx, queueType, firstMessageID, lastMessageID, maxRows interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMessagesBetween", reflect.TypeOf((*MockTx)(nil).GetMessagesBetween), ctx, queueType, firstMessageID, lastMessageID, maxRows)
}

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

// GetMessagesFromQueue indicates an expected call of GetMessagesFromQueue.
func (mr *MockTxMockRecorder) GetMessagesFromQueue(ctx, queueType, lastMessageID, maxRows interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMessagesFromQueue", reflect.TypeOf((*MockTx)(nil).GetMessagesFromQueue), ctx, queueType, lastMessageID, maxRows)
}

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

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

// GetQueueSize mocks base method.
func (m *MockTx) 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 *MockTxMockRecorder) GetQueueSize(ctx, queueType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueSize", reflect.TypeOf((*MockTx)(nil).GetQueueSize), ctx, queueType)
}

// GetTasksCount mocks base method.
func (m *MockTx) 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 *MockTxMockRecorder) GetTasksCount(ctx, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTasksCount", reflect.TypeOf((*MockTx)(nil).GetTasksCount), ctx, filter)
}

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

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

// InsertConfig mocks base method.
func (m *MockTx) 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 *MockTxMockRecorder) InsertConfig(ctx, row interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertConfig", reflect.TypeOf((*MockTx)(nil).InsertConfig), ctx, row)
}

// InsertIntoBufferedEvents mocks base method.
func (m *MockTx) InsertIntoBufferedEvents(ctx context.Context, rows []BufferedEventsRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoBufferedEvents", ctx, rows)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoCrossClusterTasks mocks base method.
func (m *MockTx) InsertIntoCrossClusterTasks(ctx context.Context, rows []CrossClusterTasksRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoCrossClusterTasks", ctx, rows)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoCurrentExecutions mocks base method.
func (m *MockTx) InsertIntoCurrentExecutions(ctx context.Context, row *CurrentExecutionsRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoCurrentExecutions", ctx, row)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoDomain mocks base method.
func (m *MockTx) InsertIntoDomain(ctx context.Context, rows *DomainRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoDomain", ctx, rows)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoExecutions mocks base method.
func (m *MockTx) InsertIntoExecutions(ctx context.Context, row *ExecutionsRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoExecutions", ctx, row)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoHistoryNode mocks base method.
func (m *MockTx) InsertIntoHistoryNode(ctx context.Context, row *HistoryNodeRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoHistoryNode", ctx, row)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoHistoryTree mocks base method.
func (m *MockTx) InsertIntoHistoryTree(ctx context.Context, row *HistoryTreeRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoHistoryTree", ctx, row)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// InsertIntoReplicationTasks mocks base method.
func (m *MockTx) InsertIntoReplicationTasks(ctx context.Context, rows []ReplicationTasksRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoReplicationTasks", ctx, rows)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoReplicationTasksDLQ mocks base method.
func (m *MockTx) InsertIntoReplicationTasksDLQ(ctx context.Context, row *ReplicationTaskDLQRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoReplicationTasksDLQ", ctx, row)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoShards mocks base method.
func (m *MockTx) InsertIntoShards(ctx context.Context, rows *ShardsRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoShards", ctx, rows)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoSignalsRequestedSets mocks base method.
func (m *MockTx) InsertIntoSignalsRequestedSets(ctx context.Context, rows []SignalsRequestedSetsRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoSignalsRequestedSets", ctx, rows)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoTaskLists mocks base method.
func (m *MockTx) InsertIntoTaskLists(ctx context.Context, row *TaskListsRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoTaskLists", ctx, row)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoTaskListsWithTTL mocks base method.
func (m *MockTx) InsertIntoTaskListsWithTTL(ctx context.Context, row *TaskListsRowWithTTL) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoTaskListsWithTTL", ctx, row)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoTasks mocks base method.
func (m *MockTx) InsertIntoTasks(ctx context.Context, rows []TasksRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoTasks", ctx, rows)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoTasksWithTTL mocks base method.
func (m *MockTx) InsertIntoTasksWithTTL(ctx context.Context, rows []TasksRowWithTTL) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoTasksWithTTL", ctx, rows)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoTimerTasks mocks base method.
func (m *MockTx) InsertIntoTimerTasks(ctx context.Context, rows []TimerTasksRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoTimerTasks", ctx, rows)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoTransferTasks mocks base method.
func (m *MockTx) InsertIntoTransferTasks(ctx context.Context, rows []TransferTasksRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoTransferTasks", ctx, rows)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InsertIntoVisibility mocks base method.
func (m *MockTx) InsertIntoVisibility(ctx context.Context, row *VisibilityRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertIntoVisibility", ctx, row)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// IsDupEntryError indicates an expected call of IsDupEntryError.
func (mr *MockTxMockRecorder) IsDupEntryError(err interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsDupEntryError", reflect.TypeOf((*MockTx)(nil).IsDupEntryError), err)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MaxAllowedTTL mocks base method.
func (m *MockTx) MaxAllowedTTL() (*time.Duration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MaxAllowedTTL")
	ret0, _ := ret[0].(*time.Duration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RangeDeleteFromCrossClusterTasks mocks base method.
func (m *MockTx) RangeDeleteFromCrossClusterTasks(ctx context.Context, filter *CrossClusterTasksFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteFromCrossClusterTasks", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RangeDeleteFromReplicationTasks mocks base method.
func (m *MockTx) RangeDeleteFromReplicationTasks(ctx context.Context, filter *ReplicationTasksFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteFromReplicationTasks", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RangeDeleteFromTimerTasks mocks base method.
func (m *MockTx) RangeDeleteFromTimerTasks(ctx context.Context, filter *TimerTasksFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteFromTimerTasks", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RangeDeleteFromTransferTasks mocks base method.
func (m *MockTx) RangeDeleteFromTransferTasks(ctx context.Context, filter *TransferTasksFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteFromTransferTasks", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RangeDeleteMessageFromReplicationTasksDLQ mocks base method.
func (m *MockTx) RangeDeleteMessageFromReplicationTasksDLQ(ctx context.Context, filter *ReplicationTasksDLQFilter) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteMessageFromReplicationTasksDLQ", ctx, filter)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// ReplaceIntoActivityInfoMaps mocks base method.
func (m *MockTx) ReplaceIntoActivityInfoMaps(ctx context.Context, rows []ActivityInfoMapsRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceIntoActivityInfoMaps", ctx, rows)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReplaceIntoChildExecutionInfoMaps mocks base method.
func (m *MockTx) ReplaceIntoChildExecutionInfoMaps(ctx context.Context, rows []ChildExecutionInfoMapsRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceIntoChildExecutionInfoMaps", ctx, rows)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReplaceIntoRequestCancelInfoMaps mocks base method.
func (m *MockTx) ReplaceIntoRequestCancelInfoMaps(ctx context.Context, rows []RequestCancelInfoMapsRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceIntoRequestCancelInfoMaps", ctx, rows)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReplaceIntoSignalInfoMaps mocks base method.
func (m *MockTx) ReplaceIntoSignalInfoMaps(ctx context.Context, rows []SignalInfoMapsRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceIntoSignalInfoMaps", ctx, rows)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReplaceIntoTimerInfoMaps mocks base method.
func (m *MockTx) ReplaceIntoTimerInfoMaps(ctx context.Context, rows []TimerInfoMapsRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceIntoTimerInfoMaps", ctx, rows)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReplaceIntoVisibility mocks base method.
func (m *MockTx) ReplaceIntoVisibility(ctx context.Context, row *VisibilityRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceIntoVisibility", ctx, row)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SelectFromHistoryTree mocks base method.
func (m *MockTx) 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 *MockTxMockRecorder) SelectFromHistoryTree(ctx, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectFromHistoryTree", reflect.TypeOf((*MockTx)(nil).SelectFromHistoryTree), ctx, filter)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SelectLatestConfig mocks base method.
func (m *MockTx) 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 *MockTxMockRecorder) SelectLatestConfig(ctx, rowType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectLatestConfig", reflect.TypeOf((*MockTx)(nil).SelectLatestConfig), ctx, rowType)
}

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

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

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

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

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

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

// UpdateCurrentExecutions mocks base method.
func (m *MockTx) UpdateCurrentExecutions(ctx context.Context, row *CurrentExecutionsRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCurrentExecutions", ctx, row)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// UpdateDomainMetadata mocks base method.
func (m *MockTx) UpdateDomainMetadata(ctx context.Context, row *DomainMetadataRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDomainMetadata", ctx, row)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateExecutions mocks base method.
func (m *MockTx) UpdateExecutions(ctx context.Context, row *ExecutionsRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateExecutions", ctx, row)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateShards mocks base method.
func (m *MockTx) UpdateShards(ctx context.Context, row *ShardsRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateShards", ctx, row)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTaskLists mocks base method.
func (m *MockTx) UpdateTaskLists(ctx context.Context, row *TaskListsRow) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskLists", ctx, row)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTaskListsWithTTL mocks base method.
func (m *MockTx) UpdateTaskListsWithTTL(ctx context.Context, row *TaskListsRowWithTTL) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskListsWithTTL", ctx, row)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// 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
}

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

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

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

// 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))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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)
}

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

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

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

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

// 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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MaxAllowedTTL mocks base method.
func (m *MockDB) MaxAllowedTTL() (*time.Duration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MaxAllowedTTL")
	ret0, _ := ret[0].(*time.Duration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// 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))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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)
}

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

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

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

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

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

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

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

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

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

// 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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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
}

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

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

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

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

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

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

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

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

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

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

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

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

// ExecSchemaOperationQuery mocks base method.
func (m *MockAdminDB) ExecSchemaOperationQuery(ctx context.Context, stmt string, args ...interface{}) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, stmt}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExecSchemaOperationQuery", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ExecSchemaOperationQuery indicates an expected call of ExecSchemaOperationQuery.
func (mr *MockAdminDBMockRecorder) ExecSchemaOperationQuery(ctx, stmt interface{}, args ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, stmt}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecSchemaOperationQuery", reflect.TypeOf((*MockAdminDB)(nil).ExecSchemaOperationQuery), varargs...)
}

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

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

// PluginName mocks base method.
func (m *MockAdminDB) 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 *MockAdminDBMockRecorder) PluginName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginName", reflect.TypeOf((*MockAdminDB)(nil).PluginName))
}

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

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

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

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

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

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

// MockErrorChecker is a mock of ErrorChecker interface.
type MockErrorChecker struct {
	ctrl     *gomock.Controller
	recorder *MockErrorCheckerMockRecorder
}

// MockErrorCheckerMockRecorder is the mock recorder for MockErrorChecker.
type MockErrorCheckerMockRecorder struct {
	mock *MockErrorChecker
}

// NewMockErrorChecker creates a new mock instance.
func NewMockErrorChecker(ctrl *gomock.Controller) *MockErrorChecker {
	mock := &MockErrorChecker{ctrl: ctrl}
	mock.recorder = &MockErrorCheckerMockRecorder{mock}
	return mock
}

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

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

// IsDupEntryError indicates an expected call of IsDupEntryError.
func (mr *MockErrorCheckerMockRecorder) IsDupEntryError(err interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsDupEntryError", reflect.TypeOf((*MockErrorChecker)(nil).IsDupEntryError), err)
}

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

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

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

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

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

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