// Code generated by MockGen. DO NOT EDIT.
// Source: context.go
//
// Generated by this command:
//
//	mockgen -package shard -source context.go -destination context_mock.go -package shard github.com/uber/cadence/history/shard/context Context
//

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

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

	gomock "go.uber.org/mock/gomock"

	activecluster "github.com/uber/cadence/common/activecluster"
	cache "github.com/uber/cadence/common/cache"
	clock "github.com/uber/cadence/common/clock"
	cluster "github.com/uber/cadence/common/cluster"
	log "github.com/uber/cadence/common/log"
	metrics "github.com/uber/cadence/common/metrics"
	persistence "github.com/uber/cadence/common/persistence"
	types "github.com/uber/cadence/common/types"
	config "github.com/uber/cadence/service/history/config"
	engine "github.com/uber/cadence/service/history/engine"
	events "github.com/uber/cadence/service/history/events"
	resource "github.com/uber/cadence/service/history/resource"
)

// MockContext is a mock of Context interface.
type MockContext struct {
	ctrl     *gomock.Controller
	recorder *MockContextMockRecorder
	isgomock struct{}
}

// MockContextMockRecorder is the mock recorder for MockContext.
type MockContextMockRecorder struct {
	mock *MockContext
}

// NewMockContext creates a new mock instance.
func NewMockContext(ctrl *gomock.Controller) *MockContext {
	mock := &MockContext{ctrl: ctrl}
	mock.recorder = &MockContextMockRecorder{mock}
	return mock
}

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

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

// AddingPendingFailoverMarker indicates an expected call of AddingPendingFailoverMarker.
func (mr *MockContextMockRecorder) AddingPendingFailoverMarker(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddingPendingFailoverMarker", reflect.TypeOf((*MockContext)(nil).AddingPendingFailoverMarker), arg0)
}

// AppendHistoryV2Events mocks base method.
func (m *MockContext) AppendHistoryV2Events(ctx context.Context, request *persistence.AppendHistoryNodesRequest, domainID string, execution types.WorkflowExecution) (*persistence.AppendHistoryNodesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppendHistoryV2Events", ctx, request, domainID, execution)
	ret0, _ := ret[0].(*persistence.AppendHistoryNodesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AppendHistoryV2Events indicates an expected call of AppendHistoryV2Events.
func (mr *MockContextMockRecorder) AppendHistoryV2Events(ctx, request, domainID, execution any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendHistoryV2Events", reflect.TypeOf((*MockContext)(nil).AppendHistoryV2Events), ctx, request, domainID, execution)
}

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

// ConflictResolveWorkflowExecution indicates an expected call of ConflictResolveWorkflowExecution.
func (mr *MockContextMockRecorder) ConflictResolveWorkflowExecution(ctx, request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConflictResolveWorkflowExecution", reflect.TypeOf((*MockContext)(nil).ConflictResolveWorkflowExecution), ctx, request)
}

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

// CreateWorkflowExecution indicates an expected call of CreateWorkflowExecution.
func (mr *MockContextMockRecorder) CreateWorkflowExecution(ctx, request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkflowExecution", reflect.TypeOf((*MockContext)(nil).CreateWorkflowExecution), ctx, request)
}

// DeleteFailoverLevel mocks base method.
func (m *MockContext) DeleteFailoverLevel(category persistence.HistoryTaskCategory, failoverID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFailoverLevel", category, failoverID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteFailoverLevel indicates an expected call of DeleteFailoverLevel.
func (mr *MockContextMockRecorder) DeleteFailoverLevel(category, failoverID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFailoverLevel", reflect.TypeOf((*MockContext)(nil).DeleteFailoverLevel), category, failoverID)
}

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

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

// GenerateTaskIDs mocks base method.
func (m *MockContext) GenerateTaskIDs(number int) ([]int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateTaskIDs", number)
	ret0, _ := ret[0].([]int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenerateTaskIDs indicates an expected call of GenerateTaskIDs.
func (mr *MockContextMockRecorder) GenerateTaskIDs(number any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateTaskIDs", reflect.TypeOf((*MockContext)(nil).GenerateTaskIDs), number)
}

// GetActiveClusterManager mocks base method.
func (m *MockContext) GetActiveClusterManager() activecluster.Manager {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActiveClusterManager")
	ret0, _ := ret[0].(activecluster.Manager)
	return ret0
}

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

// GetAllFailoverLevels mocks base method.
func (m *MockContext) GetAllFailoverLevels(category persistence.HistoryTaskCategory) map[string]persistence.FailoverLevel {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllFailoverLevels", category)
	ret0, _ := ret[0].(map[string]persistence.FailoverLevel)
	return ret0
}

// GetAllFailoverLevels indicates an expected call of GetAllFailoverLevels.
func (mr *MockContextMockRecorder) GetAllFailoverLevels(category any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllFailoverLevels", reflect.TypeOf((*MockContext)(nil).GetAllFailoverLevels), category)
}

// GetClusterMetadata mocks base method.
func (m *MockContext) GetClusterMetadata() cluster.Metadata {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterMetadata")
	ret0, _ := ret[0].(cluster.Metadata)
	return ret0
}

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

// GetConfig mocks base method.
func (m *MockContext) GetConfig() *config.Config {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfig")
	ret0, _ := ret[0].(*config.Config)
	return ret0
}

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

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

// GetCurrentTime indicates an expected call of GetCurrentTime.
func (mr *MockContextMockRecorder) GetCurrentTime(cluster any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentTime", reflect.TypeOf((*MockContext)(nil).GetCurrentTime), cluster)
}

// GetDomainCache mocks base method.
func (m *MockContext) GetDomainCache() cache.DomainCache {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDomainCache")
	ret0, _ := ret[0].(cache.DomainCache)
	return ret0
}

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

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

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

// GetEngine mocks base method.
func (m *MockContext) GetEngine() engine.Engine {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEngine")
	ret0, _ := ret[0].(engine.Engine)
	return ret0
}

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

// GetEventsCache mocks base method.
func (m *MockContext) GetEventsCache() events.Cache {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEventsCache")
	ret0, _ := ret[0].(events.Cache)
	return ret0
}

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

// GetExecutionManager mocks base method.
func (m *MockContext) GetExecutionManager() persistence.ExecutionManager {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExecutionManager")
	ret0, _ := ret[0].(persistence.ExecutionManager)
	return ret0
}

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

// GetHistoryManager mocks base method.
func (m *MockContext) GetHistoryManager() persistence.HistoryManager {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHistoryManager")
	ret0, _ := ret[0].(persistence.HistoryManager)
	return ret0
}

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

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

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

// GetLogger mocks base method.
func (m *MockContext) GetLogger() log.Logger {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogger")
	ret0, _ := ret[0].(log.Logger)
	return ret0
}

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

// GetMetricsClient mocks base method.
func (m *MockContext) GetMetricsClient() metrics.Client {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetricsClient")
	ret0, _ := ret[0].(metrics.Client)
	return ret0
}

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

// GetQueueAckLevel mocks base method.
func (m *MockContext) GetQueueAckLevel(category persistence.HistoryTaskCategory) persistence.HistoryTaskKey {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueueAckLevel", category)
	ret0, _ := ret[0].(persistence.HistoryTaskKey)
	return ret0
}

// GetQueueAckLevel indicates an expected call of GetQueueAckLevel.
func (mr *MockContextMockRecorder) GetQueueAckLevel(category any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueAckLevel", reflect.TypeOf((*MockContext)(nil).GetQueueAckLevel), category)
}

// GetQueueClusterAckLevel mocks base method.
func (m *MockContext) GetQueueClusterAckLevel(category persistence.HistoryTaskCategory, cluster string) persistence.HistoryTaskKey {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueueClusterAckLevel", category, cluster)
	ret0, _ := ret[0].(persistence.HistoryTaskKey)
	return ret0
}

// GetQueueClusterAckLevel indicates an expected call of GetQueueClusterAckLevel.
func (mr *MockContextMockRecorder) GetQueueClusterAckLevel(category, cluster any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueClusterAckLevel", reflect.TypeOf((*MockContext)(nil).GetQueueClusterAckLevel), category, cluster)
}

// GetQueueState mocks base method.
func (m *MockContext) GetQueueState(category persistence.HistoryTaskCategory) (*types.QueueState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueueState", category)
	ret0, _ := ret[0].(*types.QueueState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetQueueState indicates an expected call of GetQueueState.
func (mr *MockContextMockRecorder) GetQueueState(category any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueState", reflect.TypeOf((*MockContext)(nil).GetQueueState), category)
}

// GetService mocks base method.
func (m *MockContext) GetService() resource.Resource {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetService")
	ret0, _ := ret[0].(resource.Resource)
	return ret0
}

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

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

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

// GetThrottledLogger mocks base method.
func (m *MockContext) GetThrottledLogger() log.Logger {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetThrottledLogger")
	ret0, _ := ret[0].(log.Logger)
	return ret0
}

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

// GetTimeSource mocks base method.
func (m *MockContext) GetTimeSource() clock.TimeSource {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeSource")
	ret0, _ := ret[0].(clock.TimeSource)
	return ret0
}

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

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

// GetTimerProcessingQueueStates indicates an expected call of GetTimerProcessingQueueStates.
func (mr *MockContextMockRecorder) GetTimerProcessingQueueStates(cluster any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimerProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).GetTimerProcessingQueueStates), cluster)
}

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

// GetTransferProcessingQueueStates indicates an expected call of GetTransferProcessingQueueStates.
func (mr *MockContextMockRecorder) GetTransferProcessingQueueStates(cluster any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransferProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).GetTransferProcessingQueueStates), cluster)
}

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

// GetWorkflowExecution indicates an expected call of GetWorkflowExecution.
func (mr *MockContextMockRecorder) GetWorkflowExecution(ctx, request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowExecution", reflect.TypeOf((*MockContext)(nil).GetWorkflowExecution), ctx, request)
}

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

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

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

// ReplicateFailoverMarkers indicates an expected call of ReplicateFailoverMarkers.
func (mr *MockContextMockRecorder) ReplicateFailoverMarkers(ctx, markers any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicateFailoverMarkers", reflect.TypeOf((*MockContext)(nil).ReplicateFailoverMarkers), ctx, markers)
}

// SetCurrentTime mocks base method.
func (m *MockContext) SetCurrentTime(cluster string, currentTime time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCurrentTime", cluster, currentTime)
}

// SetCurrentTime indicates an expected call of SetCurrentTime.
func (mr *MockContextMockRecorder) SetCurrentTime(cluster, currentTime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentTime", reflect.TypeOf((*MockContext)(nil).SetCurrentTime), cluster, currentTime)
}

// SetEngine mocks base method.
func (m *MockContext) SetEngine(arg0 engine.Engine) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetEngine", arg0)
}

// SetEngine indicates an expected call of SetEngine.
func (mr *MockContextMockRecorder) SetEngine(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEngine", reflect.TypeOf((*MockContext)(nil).SetEngine), arg0)
}

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

// UpdateDomainNotificationVersion indicates an expected call of UpdateDomainNotificationVersion.
func (mr *MockContextMockRecorder) UpdateDomainNotificationVersion(domainNotificationVersion any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDomainNotificationVersion", reflect.TypeOf((*MockContext)(nil).UpdateDomainNotificationVersion), domainNotificationVersion)
}

// UpdateFailoverLevel mocks base method.
func (m *MockContext) UpdateFailoverLevel(category persistence.HistoryTaskCategory, failoverID string, level persistence.FailoverLevel) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFailoverLevel", category, failoverID, level)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateFailoverLevel indicates an expected call of UpdateFailoverLevel.
func (mr *MockContextMockRecorder) UpdateFailoverLevel(category, failoverID, level any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFailoverLevel", reflect.TypeOf((*MockContext)(nil).UpdateFailoverLevel), category, failoverID, level)
}

// UpdateIfNeededAndGetQueueMaxReadLevel mocks base method.
func (m *MockContext) UpdateIfNeededAndGetQueueMaxReadLevel(category persistence.HistoryTaskCategory, cluster string) persistence.HistoryTaskKey {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIfNeededAndGetQueueMaxReadLevel", category, cluster)
	ret0, _ := ret[0].(persistence.HistoryTaskKey)
	return ret0
}

// UpdateIfNeededAndGetQueueMaxReadLevel indicates an expected call of UpdateIfNeededAndGetQueueMaxReadLevel.
func (mr *MockContextMockRecorder) UpdateIfNeededAndGetQueueMaxReadLevel(category, cluster any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIfNeededAndGetQueueMaxReadLevel", reflect.TypeOf((*MockContext)(nil).UpdateIfNeededAndGetQueueMaxReadLevel), category, cluster)
}

// UpdateQueueAckLevel mocks base method.
func (m *MockContext) UpdateQueueAckLevel(category persistence.HistoryTaskCategory, ackLevel persistence.HistoryTaskKey) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateQueueAckLevel", category, ackLevel)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateQueueAckLevel indicates an expected call of UpdateQueueAckLevel.
func (mr *MockContextMockRecorder) UpdateQueueAckLevel(category, ackLevel any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateQueueAckLevel", reflect.TypeOf((*MockContext)(nil).UpdateQueueAckLevel), category, ackLevel)
}

// UpdateQueueClusterAckLevel mocks base method.
func (m *MockContext) UpdateQueueClusterAckLevel(category persistence.HistoryTaskCategory, cluster string, ackLevel persistence.HistoryTaskKey) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateQueueClusterAckLevel", category, cluster, ackLevel)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateQueueClusterAckLevel indicates an expected call of UpdateQueueClusterAckLevel.
func (mr *MockContextMockRecorder) UpdateQueueClusterAckLevel(category, cluster, ackLevel any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateQueueClusterAckLevel", reflect.TypeOf((*MockContext)(nil).UpdateQueueClusterAckLevel), category, cluster, ackLevel)
}

// UpdateQueueState mocks base method.
func (m *MockContext) UpdateQueueState(category persistence.HistoryTaskCategory, state *types.QueueState) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateQueueState", category, state)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateQueueState indicates an expected call of UpdateQueueState.
func (mr *MockContextMockRecorder) UpdateQueueState(category, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateQueueState", reflect.TypeOf((*MockContext)(nil).UpdateQueueState), category, state)
}

// UpdateTimerProcessingQueueStates mocks base method.
func (m *MockContext) UpdateTimerProcessingQueueStates(cluster string, states []*types.ProcessingQueueState) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTimerProcessingQueueStates", cluster, states)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTimerProcessingQueueStates indicates an expected call of UpdateTimerProcessingQueueStates.
func (mr *MockContextMockRecorder) UpdateTimerProcessingQueueStates(cluster, states any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTimerProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).UpdateTimerProcessingQueueStates), cluster, states)
}

// UpdateTransferProcessingQueueStates mocks base method.
func (m *MockContext) UpdateTransferProcessingQueueStates(cluster string, states []*types.ProcessingQueueState) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTransferProcessingQueueStates", cluster, states)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTransferProcessingQueueStates indicates an expected call of UpdateTransferProcessingQueueStates.
func (mr *MockContextMockRecorder) UpdateTransferProcessingQueueStates(cluster, states any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTransferProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).UpdateTransferProcessingQueueStates), cluster, states)
}

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

// UpdateWorkflowExecution indicates an expected call of UpdateWorkflowExecution.
func (mr *MockContextMockRecorder) UpdateWorkflowExecution(ctx, request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkflowExecution", reflect.TypeOf((*MockContext)(nil).UpdateWorkflowExecution), ctx, request)
}

// ValidateAndUpdateFailoverMarkers mocks base method.
func (m *MockContext) ValidateAndUpdateFailoverMarkers() ([]*types.FailoverMarkerAttributes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateAndUpdateFailoverMarkers")
	ret0, _ := ret[0].([]*types.FailoverMarkerAttributes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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