MockMutableState.go

// Copyright (c) 2017 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.

package history

import (
	"time"

	"github.com/stretchr/testify/mock"
	h "github.com/uber/cadence/.gen/go/history"
	"github.com/uber/cadence/.gen/go/shared"
	"github.com/uber/cadence/common/cache"
	"github.com/uber/cadence/common/persistence"
)

var _ mutableState = (*mockMutableState)(nil)

// mockMutableState is an autogenerated mock type for the mockMutableState type
type mockMutableState struct {
	mock.Mock
}

// AddActivityTaskCancelRequestedEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddActivityTaskCancelRequestedEvent(_a0 int64, _a1 string, _a2 string) (*shared.HistoryEvent, *persistence.ActivityInfo, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, string, string) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 *persistence.ActivityInfo
	if rf, ok := ret.Get(1).(func(int64, string, string) *persistence.ActivityInfo); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*persistence.ActivityInfo)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(int64, string, string) error); ok {
		r2 = rf(_a0, _a1, _a2)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// AddActivityTaskCanceledEvent provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4
func (_m *mockMutableState) AddActivityTaskCanceledEvent(_a0 int64, _a1 int64, _a2 int64, _a3 []uint8, _a4 string) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2, _a3, _a4)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, int64, int64, []uint8, string) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2, _a3, _a4)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, int64, int64, []uint8, string) error); ok {
		r1 = rf(_a0, _a1, _a2, _a3, _a4)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddActivityTaskCompletedEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddActivityTaskCompletedEvent(_a0 int64, _a1 int64, _a2 *shared.RespondActivityTaskCompletedRequest) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, int64, *shared.RespondActivityTaskCompletedRequest) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, int64, *shared.RespondActivityTaskCompletedRequest) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddActivityTaskFailedEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddActivityTaskFailedEvent(_a0 int64, _a1 int64, _a2 *shared.RespondActivityTaskFailedRequest) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, int64, *shared.RespondActivityTaskFailedRequest) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, int64, *shared.RespondActivityTaskFailedRequest) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddActivityTaskScheduledEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) AddActivityTaskScheduledEvent(_a0 int64, _a1 *shared.ScheduleActivityTaskDecisionAttributes) (*shared.HistoryEvent, *persistence.ActivityInfo, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, *shared.ScheduleActivityTaskDecisionAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 *persistence.ActivityInfo
	if rf, ok := ret.Get(1).(func(int64, *shared.ScheduleActivityTaskDecisionAttributes) *persistence.ActivityInfo); ok {
		r1 = rf(_a0, _a1)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*persistence.ActivityInfo)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(int64, *shared.ScheduleActivityTaskDecisionAttributes) error); ok {
		r2 = rf(_a0, _a1)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// AddActivityTaskStartedEvent provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *mockMutableState) AddActivityTaskStartedEvent(_a0 *persistence.ActivityInfo, _a1 int64, _a2 string, _a3 string) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2, _a3)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(*persistence.ActivityInfo, int64, string, string) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2, _a3)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*persistence.ActivityInfo, int64, string, string) error); ok {
		r1 = rf(_a0, _a1, _a2, _a3)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddActivityTaskTimedOutEvent provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *mockMutableState) AddActivityTaskTimedOutEvent(_a0 int64, _a1 int64, _a2 shared.TimeoutType, _a3 []uint8) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2, _a3)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, int64, shared.TimeoutType, []uint8) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2, _a3)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, int64, shared.TimeoutType, []uint8) error); ok {
		r1 = rf(_a0, _a1, _a2, _a3)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddCancelTimerFailedEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddCancelTimerFailedEvent(_a0 int64, _a1 *shared.CancelTimerDecisionAttributes, _a2 string) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, *shared.CancelTimerDecisionAttributes, string) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, *shared.CancelTimerDecisionAttributes, string) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddChildWorkflowExecutionCanceledEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddChildWorkflowExecutionCanceledEvent(_a0 int64, _a1 *shared.WorkflowExecution, _a2 *shared.WorkflowExecutionCanceledEventAttributes) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, *shared.WorkflowExecution, *shared.WorkflowExecutionCanceledEventAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, *shared.WorkflowExecution, *shared.WorkflowExecutionCanceledEventAttributes) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddChildWorkflowExecutionCompletedEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddChildWorkflowExecutionCompletedEvent(_a0 int64, _a1 *shared.WorkflowExecution, _a2 *shared.WorkflowExecutionCompletedEventAttributes) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, *shared.WorkflowExecution, *shared.WorkflowExecutionCompletedEventAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, *shared.WorkflowExecution, *shared.WorkflowExecutionCompletedEventAttributes) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddChildWorkflowExecutionFailedEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddChildWorkflowExecutionFailedEvent(_a0 int64, _a1 *shared.WorkflowExecution, _a2 *shared.WorkflowExecutionFailedEventAttributes) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, *shared.WorkflowExecution, *shared.WorkflowExecutionFailedEventAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, *shared.WorkflowExecution, *shared.WorkflowExecutionFailedEventAttributes) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddChildWorkflowExecutionStartedEvent provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4
func (_m *mockMutableState) AddChildWorkflowExecutionStartedEvent(_a0 *string, _a1 *shared.WorkflowExecution, _a2 *shared.WorkflowType, _a3 int64, _a4 *shared.Header) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2, _a3, _a4)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(*string, *shared.WorkflowExecution, *shared.WorkflowType, int64, *shared.Header) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2, _a3, _a4)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*string, *shared.WorkflowExecution, *shared.WorkflowType, int64, *shared.Header) error); ok {
		r1 = rf(_a0, _a1, _a2, _a3, _a4)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddChildWorkflowExecutionTerminatedEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddChildWorkflowExecutionTerminatedEvent(_a0 int64, _a1 *shared.WorkflowExecution, _a2 *shared.WorkflowExecutionTerminatedEventAttributes) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, *shared.WorkflowExecution, *shared.WorkflowExecutionTerminatedEventAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, *shared.WorkflowExecution, *shared.WorkflowExecutionTerminatedEventAttributes) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddChildWorkflowExecutionTimedOutEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddChildWorkflowExecutionTimedOutEvent(_a0 int64, _a1 *shared.WorkflowExecution, _a2 *shared.WorkflowExecutionTimedOutEventAttributes) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, *shared.WorkflowExecution, *shared.WorkflowExecutionTimedOutEventAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, *shared.WorkflowExecution, *shared.WorkflowExecutionTimedOutEventAttributes) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddCompletedWorkflowEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) AddCompletedWorkflowEvent(_a0 int64, _a1 *shared.CompleteWorkflowExecutionDecisionAttributes) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, *shared.CompleteWorkflowExecutionDecisionAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, *shared.CompleteWorkflowExecutionDecisionAttributes) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddContinueAsNewEvent provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4, _a5
func (_m *mockMutableState) AddContinueAsNewEvent(_a0 int64, _a1 int64, _a2 *cache.DomainCacheEntry, _a3 string, _a4 *shared.ContinueAsNewWorkflowExecutionDecisionAttributes, _a5 int32) (*shared.HistoryEvent, mutableState, error) {
	ret := _m.Called(_a0, _a1, _a2, _a3, _a4, _a5)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, int64, *cache.DomainCacheEntry, string, *shared.ContinueAsNewWorkflowExecutionDecisionAttributes, int32) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2, _a3, _a4, _a5)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 mutableState
	if rf, ok := ret.Get(1).(func(int64, int64, *cache.DomainCacheEntry, string, *shared.ContinueAsNewWorkflowExecutionDecisionAttributes, int32) mutableState); ok {
		r1 = rf(_a0, _a1, _a2, _a3, _a4, _a5)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(mutableState)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(int64, int64, *cache.DomainCacheEntry, string, *shared.ContinueAsNewWorkflowExecutionDecisionAttributes, int32) error); ok {
		r2 = rf(_a0, _a1, _a2, _a3, _a4, _a5)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// AddDecisionTaskCompletedEvent provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *mockMutableState) AddDecisionTaskCompletedEvent(_a0 int64, _a1 int64, _a2 *shared.RespondDecisionTaskCompletedRequest, _a3 int) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2, _a3)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, int64, *shared.RespondDecisionTaskCompletedRequest, int) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2, _a3)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, int64, *shared.RespondDecisionTaskCompletedRequest, int) error); ok {
		r1 = rf(_a0, _a1, _a2, _a3)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddDecisionTaskFailedEvent provides a mock function with given fields: scheduleEventID, startedEventID, cause, details, identity, reason, baseRunID, newRunID, forkEventVersion
func (_m *mockMutableState) AddDecisionTaskFailedEvent(scheduleEventID int64, startedEventID int64, cause shared.DecisionTaskFailedCause, details []byte, identity string, reason string, baseRunID string, newRunID string, forkEventVersion int64) (*shared.HistoryEvent, error) {
	ret := _m.Called(scheduleEventID, startedEventID, cause, details, identity, reason, baseRunID, newRunID, forkEventVersion)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, int64, shared.DecisionTaskFailedCause, []byte, string, string, string, string, int64) *shared.HistoryEvent); ok {
		r0 = rf(scheduleEventID, startedEventID, cause, details, identity, reason, baseRunID, newRunID, forkEventVersion)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, int64, shared.DecisionTaskFailedCause, []byte, string, string, string, string, int64) error); ok {
		r1 = rf(scheduleEventID, startedEventID, cause, details, identity, reason, baseRunID, newRunID, forkEventVersion)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddDecisionTaskScheduleToStartTimeoutEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) AddDecisionTaskScheduleToStartTimeoutEvent(_a0 int64) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64) *shared.HistoryEvent); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddDecisionTaskScheduledEvent provides a mock function with given fields:
func (_m *mockMutableState) AddDecisionTaskScheduledEvent() (*decisionInfo, error) {
	ret := _m.Called()

	var r0 *decisionInfo
	if rf, ok := ret.Get(0).(func() *decisionInfo); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*decisionInfo)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddDecisionTaskStartedEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddDecisionTaskStartedEvent(_a0 int64, _a1 string, _a2 *shared.PollForDecisionTaskRequest) (*shared.HistoryEvent, *decisionInfo, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, string, *shared.PollForDecisionTaskRequest) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 *decisionInfo
	if rf, ok := ret.Get(1).(func(int64, string, *shared.PollForDecisionTaskRequest) *decisionInfo); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*decisionInfo)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(int64, string, *shared.PollForDecisionTaskRequest) error); ok {
		r2 = rf(_a0, _a1, _a2)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// AddDecisionTaskTimedOutEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) AddDecisionTaskTimedOutEvent(_a0 int64, _a1 int64) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, int64) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, int64) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddExternalWorkflowExecutionCancelRequested provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *mockMutableState) AddExternalWorkflowExecutionCancelRequested(_a0 int64, _a1 string, _a2 string, _a3 string) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2, _a3)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, string, string, string) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2, _a3)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, string, string, string) error); ok {
		r1 = rf(_a0, _a1, _a2, _a3)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddExternalWorkflowExecutionSignaled provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4
func (_m *mockMutableState) AddExternalWorkflowExecutionSignaled(_a0 int64, _a1 string, _a2 string, _a3 string, _a4 []uint8) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2, _a3, _a4)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, string, string, string, []uint8) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2, _a3, _a4)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, string, string, string, []uint8) error); ok {
		r1 = rf(_a0, _a1, _a2, _a3, _a4)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddFailWorkflowEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) AddFailWorkflowEvent(_a0 int64, _a1 *shared.FailWorkflowExecutionDecisionAttributes) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, *shared.FailWorkflowExecutionDecisionAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, *shared.FailWorkflowExecutionDecisionAttributes) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddRecordMarkerEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) AddRecordMarkerEvent(_a0 int64, _a1 *shared.RecordMarkerDecisionAttributes) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, *shared.RecordMarkerDecisionAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, *shared.RecordMarkerDecisionAttributes) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddRequestCancelActivityTaskFailedEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddRequestCancelActivityTaskFailedEvent(_a0 int64, _a1 string, _a2 string) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, string, string) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, string, string) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddRequestCancelExternalWorkflowExecutionFailedEvent provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4, _a5
func (_m *mockMutableState) AddRequestCancelExternalWorkflowExecutionFailedEvent(_a0 int64, _a1 int64, _a2 string, _a3 string, _a4 string, _a5 shared.CancelExternalWorkflowExecutionFailedCause) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2, _a3, _a4, _a5)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, int64, string, string, string, shared.CancelExternalWorkflowExecutionFailedCause) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2, _a3, _a4, _a5)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, int64, string, string, string, shared.CancelExternalWorkflowExecutionFailedCause) error); ok {
		r1 = rf(_a0, _a1, _a2, _a3, _a4, _a5)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddRequestCancelExternalWorkflowExecutionInitiatedEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddRequestCancelExternalWorkflowExecutionInitiatedEvent(_a0 int64, _a1 string, _a2 *shared.RequestCancelExternalWorkflowExecutionDecisionAttributes) (*shared.HistoryEvent, *persistence.RequestCancelInfo, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, string, *shared.RequestCancelExternalWorkflowExecutionDecisionAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 *persistence.RequestCancelInfo
	if rf, ok := ret.Get(1).(func(int64, string, *shared.RequestCancelExternalWorkflowExecutionDecisionAttributes) *persistence.RequestCancelInfo); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*persistence.RequestCancelInfo)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(int64, string, *shared.RequestCancelExternalWorkflowExecutionDecisionAttributes) error); ok {
		r2 = rf(_a0, _a1, _a2)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// AddSignalExternalWorkflowExecutionFailedEvent provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4, _a5, _a6
func (_m *mockMutableState) AddSignalExternalWorkflowExecutionFailedEvent(_a0 int64, _a1 int64, _a2 string, _a3 string, _a4 string, _a5 []uint8, _a6 shared.SignalExternalWorkflowExecutionFailedCause) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2, _a3, _a4, _a5, _a6)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, int64, string, string, string, []uint8, shared.SignalExternalWorkflowExecutionFailedCause) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2, _a3, _a4, _a5, _a6)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, int64, string, string, string, []uint8, shared.SignalExternalWorkflowExecutionFailedCause) error); ok {
		r1 = rf(_a0, _a1, _a2, _a3, _a4, _a5, _a6)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddSignalExternalWorkflowExecutionInitiatedEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddSignalExternalWorkflowExecutionInitiatedEvent(_a0 int64, _a1 string, _a2 *shared.SignalExternalWorkflowExecutionDecisionAttributes) (*shared.HistoryEvent, *persistence.SignalInfo, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, string, *shared.SignalExternalWorkflowExecutionDecisionAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 *persistence.SignalInfo
	if rf, ok := ret.Get(1).(func(int64, string, *shared.SignalExternalWorkflowExecutionDecisionAttributes) *persistence.SignalInfo); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*persistence.SignalInfo)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(int64, string, *shared.SignalExternalWorkflowExecutionDecisionAttributes) error); ok {
		r2 = rf(_a0, _a1, _a2)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// AddSignalRequested provides a mock function with given fields: requestID
func (_m *mockMutableState) AddSignalRequested(requestID string) {
	_m.Called(requestID)
}

// AddStartChildWorkflowExecutionFailedEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddStartChildWorkflowExecutionFailedEvent(_a0 int64, _a1 shared.ChildWorkflowExecutionFailedCause, _a2 *shared.StartChildWorkflowExecutionInitiatedEventAttributes) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, shared.ChildWorkflowExecutionFailedCause, *shared.StartChildWorkflowExecutionInitiatedEventAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, shared.ChildWorkflowExecutionFailedCause, *shared.StartChildWorkflowExecutionInitiatedEventAttributes) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddStartChildWorkflowExecutionInitiatedEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddStartChildWorkflowExecutionInitiatedEvent(_a0 int64, _a1 string, _a2 *shared.StartChildWorkflowExecutionDecisionAttributes) (*shared.HistoryEvent, *persistence.ChildExecutionInfo, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, string, *shared.StartChildWorkflowExecutionDecisionAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 *persistence.ChildExecutionInfo
	if rf, ok := ret.Get(1).(func(int64, string, *shared.StartChildWorkflowExecutionDecisionAttributes) *persistence.ChildExecutionInfo); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*persistence.ChildExecutionInfo)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(int64, string, *shared.StartChildWorkflowExecutionDecisionAttributes) error); ok {
		r2 = rf(_a0, _a1, _a2)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// AddTimeoutWorkflowEvent provides a mock function with given fields:
func (_m *mockMutableState) AddTimeoutWorkflowEvent() (*shared.HistoryEvent, error) {
	ret := _m.Called()

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func() *shared.HistoryEvent); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddTimerCanceledEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddTimerCanceledEvent(_a0 int64, _a1 *shared.CancelTimerDecisionAttributes, _a2 string) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, *shared.CancelTimerDecisionAttributes, string) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, *shared.CancelTimerDecisionAttributes, string) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddTimerFiredEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) AddTimerFiredEvent(_a0 int64, _a1 string) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, string) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, string) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddTimerStartedEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) AddTimerStartedEvent(_a0 int64, _a1 *shared.StartTimerDecisionAttributes) (*shared.HistoryEvent, *persistence.TimerInfo, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, *shared.StartTimerDecisionAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 *persistence.TimerInfo
	if rf, ok := ret.Get(1).(func(int64, *shared.StartTimerDecisionAttributes) *persistence.TimerInfo); ok {
		r1 = rf(_a0, _a1)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*persistence.TimerInfo)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(int64, *shared.StartTimerDecisionAttributes) error); ok {
		r2 = rf(_a0, _a1)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// AddUpsertWorkflowSearchAttributesEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) AddUpsertWorkflowSearchAttributesEvent(_a0 int64, _a1 *shared.UpsertWorkflowSearchAttributesDecisionAttributes) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, *shared.UpsertWorkflowSearchAttributesDecisionAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, *shared.UpsertWorkflowSearchAttributesDecisionAttributes) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddWorkflowExecutionCancelRequestedEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) AddWorkflowExecutionCancelRequestedEvent(_a0 string, _a1 *h.RequestCancelWorkflowExecutionRequest) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(string, *h.RequestCancelWorkflowExecutionRequest) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, *h.RequestCancelWorkflowExecutionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddWorkflowExecutionCanceledEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) AddWorkflowExecutionCanceledEvent(_a0 int64, _a1 *shared.CancelWorkflowExecutionDecisionAttributes) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64, *shared.CancelWorkflowExecutionDecisionAttributes) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, *shared.CancelWorkflowExecutionDecisionAttributes) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddWorkflowExecutionSignaled provides a mock function with given fields: signalName, input, identity
func (_m *mockMutableState) AddWorkflowExecutionSignaled(signalName string, input []byte, identity string) (*shared.HistoryEvent, error) {
	ret := _m.Called(signalName, input, identity)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(string, []byte, string) *shared.HistoryEvent); ok {
		r0 = rf(signalName, input, identity)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, []byte, string) error); ok {
		r1 = rf(signalName, input, identity)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddWorkflowExecutionStartedEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) AddWorkflowExecutionStartedEvent(_a0 *cache.DomainCacheEntry, _a1 shared.WorkflowExecution, _a2 *h.StartWorkflowExecutionRequest) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(*cache.DomainCacheEntry, shared.WorkflowExecution, *h.StartWorkflowExecutionRequest) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*cache.DomainCacheEntry, shared.WorkflowExecution, *h.StartWorkflowExecutionRequest) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddWorkflowExecutionTerminatedEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) AddWorkflowExecutionTerminatedEvent(_a0 string, _a1 []byte, _a2 string) (*shared.HistoryEvent, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(string, []byte, string) *shared.HistoryEvent); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, []byte, string) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CheckResettable provides a mock function with given fields:
func (_m *mockMutableState) CheckResettable() error {
	ret := _m.Called()

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ClearStickyness provides a mock function with given fields:
func (_m *mockMutableState) ClearStickyness() {
	_m.Called()
}

// CopyToPersistence provides a mock function with given fields:
func (_m *mockMutableState) CopyToPersistence() *persistence.WorkflowMutableState {
	ret := _m.Called()

	var r0 *persistence.WorkflowMutableState
	if rf, ok := ret.Get(0).(func() *persistence.WorkflowMutableState); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*persistence.WorkflowMutableState)
		}
	}

	return r0
}

// CreateActivityRetryTimer provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) CreateActivityRetryTimer(_a0 *persistence.ActivityInfo, _a1 string) persistence.Task {
	ret := _m.Called(_a0, _a1)

	var r0 persistence.Task
	if rf, ok := ret.Get(0).(func(*persistence.ActivityInfo, string) persistence.Task); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(persistence.Task)
		}
	}

	return r0
}

// CreateNewHistoryEvent provides a mock function with given fields: eventType
func (_m *mockMutableState) CreateNewHistoryEvent(eventType shared.EventType) *shared.HistoryEvent {
	ret := _m.Called(eventType)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(shared.EventType) *shared.HistoryEvent); ok {
		r0 = rf(eventType)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	return r0
}

// CreateNewHistoryEventWithTimestamp provides a mock function with given fields: eventType, timestamp
func (_m *mockMutableState) CreateNewHistoryEventWithTimestamp(eventType shared.EventType, timestamp int64) *shared.HistoryEvent {
	ret := _m.Called(eventType, timestamp)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(shared.EventType, int64) *shared.HistoryEvent); ok {
		r0 = rf(eventType, timestamp)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	return r0
}

// CreateTransientDecisionEvents provides a mock function with given fields: di, identity
func (_m *mockMutableState) CreateTransientDecisionEvents(di *decisionInfo, identity string) (*shared.HistoryEvent, *shared.HistoryEvent) {
	ret := _m.Called(di, identity)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(*decisionInfo, string) *shared.HistoryEvent); ok {
		r0 = rf(di, identity)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 *shared.HistoryEvent
	if rf, ok := ret.Get(1).(func(*decisionInfo, string) *shared.HistoryEvent); ok {
		r1 = rf(di, identity)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*shared.HistoryEvent)
		}
	}

	return r0, r1
}

// DeleteActivity provides a mock function with given fields: _a0
func (_m *mockMutableState) DeleteActivity(_a0 int64) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(int64) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DeleteDecision provides a mock function with given fields:
func (_m *mockMutableState) DeleteDecision() {
	_m.Called()
}

// DeletePendingChildExecution provides a mock function with given fields: _a0
func (_m *mockMutableState) DeletePendingChildExecution(_a0 int64) {
	_m.Called(_a0)
}

// DeletePendingRequestCancel provides a mock function with given fields: _a0
func (_m *mockMutableState) DeletePendingRequestCancel(_a0 int64) {
	_m.Called(_a0)
}

// DeletePendingSignal provides a mock function with given fields: _a0
func (_m *mockMutableState) DeletePendingSignal(_a0 int64) {
	_m.Called(_a0)
}

// DeleteSignalRequested provides a mock function with given fields: requestID
func (_m *mockMutableState) DeleteSignalRequested(requestID string) {
	_m.Called(requestID)
}

// DeleteUserTimer provides a mock function with given fields: _a0
func (_m *mockMutableState) DeleteUserTimer(_a0 string) {
	_m.Called(_a0)
}

// FailDecision provides a mock function with given fields: _a0
func (_m *mockMutableState) FailDecision(_a0 bool) {
	_m.Called(_a0)
}

// FlushBufferedEvents provides a mock function with given fields:
func (_m *mockMutableState) FlushBufferedEvents() error {
	ret := _m.Called()

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetActivityByActivityID provides a mock function with given fields: _a0
func (_m *mockMutableState) GetActivityByActivityID(_a0 string) (*persistence.ActivityInfo, bool) {
	ret := _m.Called(_a0)

	var r0 *persistence.ActivityInfo
	if rf, ok := ret.Get(0).(func(string) *persistence.ActivityInfo); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*persistence.ActivityInfo)
		}
	}

	var r1 bool
	if rf, ok := ret.Get(1).(func(string) bool); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

// GetActivityInfo provides a mock function with given fields: _a0
func (_m *mockMutableState) GetActivityInfo(_a0 int64) (*persistence.ActivityInfo, bool) {
	ret := _m.Called(_a0)

	var r0 *persistence.ActivityInfo
	if rf, ok := ret.Get(0).(func(int64) *persistence.ActivityInfo); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*persistence.ActivityInfo)
		}
	}

	var r1 bool
	if rf, ok := ret.Get(1).(func(int64) bool); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

// GetActivityScheduledEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) GetActivityScheduledEvent(_a0 int64) (*shared.HistoryEvent, bool) {
	ret := _m.Called(_a0)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64) *shared.HistoryEvent); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 bool
	if rf, ok := ret.Get(1).(func(int64) bool); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

// GetAllRequestCancels provides a mock function with given fields:
func (_m *mockMutableState) GetAllRequestCancels() map[int64]*persistence.RequestCancelInfo {
	ret := _m.Called()

	var r0 map[int64]*persistence.RequestCancelInfo
	if rf, ok := ret.Get(0).(func() map[int64]*persistence.RequestCancelInfo); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[int64]*persistence.RequestCancelInfo)
		}
	}

	return r0
}

// GetAllSignalsToSend provides a mock function with given fields:
func (_m *mockMutableState) GetAllSignalsToSend() map[int64]*persistence.SignalInfo {
	ret := _m.Called()

	var r0 map[int64]*persistence.SignalInfo
	if rf, ok := ret.Get(0).(func() map[int64]*persistence.SignalInfo); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[int64]*persistence.SignalInfo)
		}
	}

	return r0
}

// GetChildExecutionInfo provides a mock function with given fields: _a0
func (_m *mockMutableState) GetChildExecutionInfo(_a0 int64) (*persistence.ChildExecutionInfo, bool) {
	ret := _m.Called(_a0)

	var r0 *persistence.ChildExecutionInfo
	if rf, ok := ret.Get(0).(func(int64) *persistence.ChildExecutionInfo); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*persistence.ChildExecutionInfo)
		}
	}

	var r1 bool
	if rf, ok := ret.Get(1).(func(int64) bool); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

// GetChildExecutionInitiatedEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) GetChildExecutionInitiatedEvent(_a0 int64) (*shared.HistoryEvent, bool) {
	ret := _m.Called(_a0)

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func(int64) *shared.HistoryEvent); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 bool
	if rf, ok := ret.Get(1).(func(int64) bool); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

// GetCompletionEvent provides a mock function with given fields:
func (_m *mockMutableState) GetCompletionEvent() (*shared.HistoryEvent, bool) {
	ret := _m.Called()

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func() *shared.HistoryEvent); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 bool
	if rf, ok := ret.Get(1).(func() bool); ok {
		r1 = rf()
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

// GetCronBackoffDuration provides a mock function with given fields:
func (_m *mockMutableState) GetCronBackoffDuration() (time.Duration, error) {
	ret := _m.Called()

	var r0 time.Duration
	if rf, ok := ret.Get(0).(func() time.Duration); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(time.Duration)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1).(error)
	}

	return r0, r1
}

// GetCurrentBranch provides a mock function with given fields:
func (_m *mockMutableState) GetCurrentBranch() []byte {
	ret := _m.Called()

	var r0 []byte
	if rf, ok := ret.Get(0).(func() []byte); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}

	return r0
}

// GetCurrentVersion provides a mock function with given fields:
func (_m *mockMutableState) GetCurrentVersion() int64 {
	ret := _m.Called()

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

// GetEventStoreVersion provides a mock function with given fields:
func (_m *mockMutableState) GetEventStoreVersion() int32 {
	ret := _m.Called()

	var r0 int32
	if rf, ok := ret.Get(0).(func() int32); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int32)
	}

	return r0
}

// GetExecutionInfo provides a mock function with given fields:
func (_m *mockMutableState) GetExecutionInfo() *persistence.WorkflowExecutionInfo {
	ret := _m.Called()

	var r0 *persistence.WorkflowExecutionInfo
	if rf, ok := ret.Get(0).(func() *persistence.WorkflowExecutionInfo); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*persistence.WorkflowExecutionInfo)
		}
	}

	return r0
}

// GetHistoryBuilder provides a mock function with given fields:
func (_m *mockMutableState) GetHistoryBuilder() *historyBuilder {
	ret := _m.Called()

	var r0 *historyBuilder
	if rf, ok := ret.Get(0).(func() *historyBuilder); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*historyBuilder)
		}
	}

	return r0
}

// GetInFlightDecisionTask provides a mock function with given fields:
func (_m *mockMutableState) GetInFlightDecisionTask() (*decisionInfo, bool) {
	ret := _m.Called()

	var r0 *decisionInfo
	if rf, ok := ret.Get(0).(func() *decisionInfo); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*decisionInfo)
		}
	}

	var r1 bool
	if rf, ok := ret.Get(1).(func() bool); ok {
		r1 = rf()
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

// GetLastFirstEventID provides a mock function with given fields:
func (_m *mockMutableState) GetLastFirstEventID() int64 {
	ret := _m.Called()

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

// GetLastWriteVersion provides a mock function with given fields:
func (_m *mockMutableState) GetLastWriteVersion() int64 {
	ret := _m.Called()

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

// GetNextEventID provides a mock function with given fields:
func (_m *mockMutableState) GetNextEventID() int64 {
	ret := _m.Called()

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

// GetPendingActivityInfos provides a mock function with given fields:
func (_m *mockMutableState) GetPendingActivityInfos() map[int64]*persistence.ActivityInfo {
	ret := _m.Called()

	var r0 map[int64]*persistence.ActivityInfo
	if rf, ok := ret.Get(0).(func() map[int64]*persistence.ActivityInfo); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[int64]*persistence.ActivityInfo)
		}
	}

	return r0
}

// GetPendingChildExecutionInfos provides a mock function with given fields:
func (_m *mockMutableState) GetPendingChildExecutionInfos() map[int64]*persistence.ChildExecutionInfo {
	ret := _m.Called()

	var r0 map[int64]*persistence.ChildExecutionInfo
	if rf, ok := ret.Get(0).(func() map[int64]*persistence.ChildExecutionInfo); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[int64]*persistence.ChildExecutionInfo)
		}
	}

	return r0
}

// GetPendingDecision provides a mock function with given fields: _a0
func (_m *mockMutableState) GetPendingDecision(_a0 int64) (*decisionInfo, bool) {
	ret := _m.Called(_a0)

	var r0 *decisionInfo
	if rf, ok := ret.Get(0).(func(int64) *decisionInfo); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*decisionInfo)
		}
	}

	var r1 bool
	if rf, ok := ret.Get(1).(func(int64) bool); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

// GetPendingTimerInfos provides a mock function with given fields:
func (_m *mockMutableState) GetPendingTimerInfos() map[string]*persistence.TimerInfo {
	ret := _m.Called()

	var r0 map[string]*persistence.TimerInfo
	if rf, ok := ret.Get(0).(func() map[string]*persistence.TimerInfo); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]*persistence.TimerInfo)
		}
	}

	return r0
}

// GetPreviousStartedEventID provides a mock function with given fields:
func (_m *mockMutableState) GetPreviousStartedEventID() int64 {
	ret := _m.Called()

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

// GetReplicationState provides a mock function with given fields:
func (_m *mockMutableState) GetReplicationState() *persistence.ReplicationState {
	ret := _m.Called()

	var r0 *persistence.ReplicationState
	if rf, ok := ret.Get(0).(func() *persistence.ReplicationState); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*persistence.ReplicationState)
		}
	}

	return r0
}

// GetRequestCancelInfo provides a mock function with given fields: _a0
func (_m *mockMutableState) GetRequestCancelInfo(_a0 int64) (*persistence.RequestCancelInfo, bool) {
	ret := _m.Called(_a0)

	var r0 *persistence.RequestCancelInfo
	if rf, ok := ret.Get(0).(func(int64) *persistence.RequestCancelInfo); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*persistence.RequestCancelInfo)
		}
	}

	var r1 bool
	if rf, ok := ret.Get(1).(func(int64) bool); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

// GetRetryBackoffDuration provides a mock function with given fields: errReason
func (_m *mockMutableState) GetRetryBackoffDuration(errReason string) time.Duration {
	ret := _m.Called(errReason)

	var r0 time.Duration
	if rf, ok := ret.Get(0).(func(string) time.Duration); ok {
		r0 = rf(errReason)
	} else {
		r0 = ret.Get(0).(time.Duration)
	}

	return r0
}

// GetScheduleIDByActivityID provides a mock function with given fields: _a0
func (_m *mockMutableState) GetScheduleIDByActivityID(_a0 string) (int64, bool) {
	ret := _m.Called(_a0)

	var r0 int64
	if rf, ok := ret.Get(0).(func(string) int64); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(int64)
	}

	var r1 bool
	if rf, ok := ret.Get(1).(func(string) bool); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

// GetSignalInfo provides a mock function with given fields: _a0
func (_m *mockMutableState) GetSignalInfo(_a0 int64) (*persistence.SignalInfo, bool) {
	ret := _m.Called(_a0)

	var r0 *persistence.SignalInfo
	if rf, ok := ret.Get(0).(func(int64) *persistence.SignalInfo); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*persistence.SignalInfo)
		}
	}

	var r1 bool
	if rf, ok := ret.Get(1).(func(int64) bool); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

// GetStartEvent provides a mock function with given fields:
func (_m *mockMutableState) GetStartEvent() (*shared.HistoryEvent, bool) {
	ret := _m.Called()

	var r0 *shared.HistoryEvent
	if rf, ok := ret.Get(0).(func() *shared.HistoryEvent); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.HistoryEvent)
		}
	}

	var r1 bool
	if rf, ok := ret.Get(1).(func() bool); ok {
		r1 = rf()
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

// GetStartVersion provides a mock function with given fields:
func (_m *mockMutableState) GetStartVersion() int64 {
	ret := _m.Called()

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

// GetUserTimer provides a mock function with given fields: _a0
func (_m *mockMutableState) GetUserTimer(_a0 string) (bool, *persistence.TimerInfo) {
	ret := _m.Called(_a0)

	var r0 bool
	if rf, ok := ret.Get(0).(func(string) bool); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(bool)
	}

	var r1 *persistence.TimerInfo
	if rf, ok := ret.Get(1).(func(string) *persistence.TimerInfo); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*persistence.TimerInfo)
		}
	}

	return r0, r1
}

// GetWorkflowType provides a mock function with given fields:
func (_m *mockMutableState) GetWorkflowType() *shared.WorkflowType {
	ret := _m.Called()

	var r0 *shared.WorkflowType
	if rf, ok := ret.Get(0).(func() *shared.WorkflowType); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shared.WorkflowType)
		}
	}

	return r0
}

// HasBufferedEvents provides a mock function with given fields:
func (_m *mockMutableState) HasBufferedEvents() bool {
	ret := _m.Called()

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// HasInFlightDecisionTask provides a mock function with given fields:
func (_m *mockMutableState) HasInFlightDecisionTask() bool {
	ret := _m.Called()

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// HasParentExecution provides a mock function with given fields:
func (_m *mockMutableState) HasParentExecution() bool {
	ret := _m.Called()

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// HasPendingDecisionTask provides a mock function with given fields:
func (_m *mockMutableState) HasPendingDecisionTask() bool {
	ret := _m.Called()

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// HasProcessedOrPendingDecisionTask provides a mock function with given fields:
func (_m *mockMutableState) HasProcessedOrPendingDecisionTask() bool {
	ret := _m.Called()

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// IsCancelRequested provides a mock function with given fields:
func (_m *mockMutableState) IsCancelRequested() (bool, string) {
	ret := _m.Called()

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	var r1 string
	if rf, ok := ret.Get(1).(func() string); ok {
		r1 = rf()
	} else {
		r1 = ret.Get(1).(string)
	}

	return r0, r1
}

// IsSignalRequested provides a mock function with given fields: requestID
func (_m *mockMutableState) IsSignalRequested(requestID string) bool {
	ret := _m.Called(requestID)

	var r0 bool
	if rf, ok := ret.Get(0).(func(string) bool); ok {
		r0 = rf(requestID)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// IsStickyTaskListEnabled provides a mock function with given fields:
func (_m *mockMutableState) IsStickyTaskListEnabled() bool {
	ret := _m.Called()

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// IsWorkflowExecutionRunning provides a mock function with given fields:
func (_m *mockMutableState) IsWorkflowExecutionRunning() bool {
	ret := _m.Called()

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// Load provides a mock function with given fields: _a0
func (_m *mockMutableState) Load(_a0 *persistence.WorkflowMutableState) {
	_m.Called(_a0)
}

// ReplicateActivityInfo provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) ReplicateActivityInfo(_a0 *h.SyncActivityRequest, _a1 bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*h.SyncActivityRequest, bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateActivityTaskCancelRequestedEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateActivityTaskCancelRequestedEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateActivityTaskCanceledEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateActivityTaskCanceledEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateActivityTaskCompletedEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateActivityTaskCompletedEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateActivityTaskFailedEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateActivityTaskFailedEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateActivityTaskScheduledEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) ReplicateActivityTaskScheduledEvent(_a0 int64, _a1 *shared.HistoryEvent) (*persistence.ActivityInfo, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *persistence.ActivityInfo
	if rf, ok := ret.Get(0).(func(int64, *shared.HistoryEvent) *persistence.ActivityInfo); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*persistence.ActivityInfo)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, *shared.HistoryEvent) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplicateActivityTaskStartedEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateActivityTaskStartedEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateActivityTaskTimedOutEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateActivityTaskTimedOutEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateChildWorkflowExecutionCanceledEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateChildWorkflowExecutionCanceledEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateChildWorkflowExecutionCompletedEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateChildWorkflowExecutionCompletedEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateChildWorkflowExecutionFailedEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateChildWorkflowExecutionFailedEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateChildWorkflowExecutionStartedEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateChildWorkflowExecutionStartedEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateChildWorkflowExecutionTerminatedEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateChildWorkflowExecutionTerminatedEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateChildWorkflowExecutionTimedOutEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateChildWorkflowExecutionTimedOutEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateDecisionTaskCompletedEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateDecisionTaskCompletedEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateDecisionTaskFailedEvent provides a mock function with given fields:
func (_m *mockMutableState) ReplicateDecisionTaskFailedEvent() error {
	ret := _m.Called()

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateDecisionTaskScheduledEvent provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4, _a5
func (_m *mockMutableState) ReplicateDecisionTaskScheduledEvent(_a0 int64, _a1 int64, _a2 string, _a3 int32, _a4 int64, _a5 int64) (*decisionInfo, error) {
	ret := _m.Called(_a0, _a1, _a2, _a3, _a4, _a5)

	var r0 *decisionInfo
	if rf, ok := ret.Get(0).(func(int64, int64, string, int32, int64, int64) *decisionInfo); ok {
		r0 = rf(_a0, _a1, _a2, _a3, _a4, _a5)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*decisionInfo)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, int64, string, int32, int64, int64) error); ok {
		r1 = rf(_a0, _a1, _a2, _a3, _a4, _a5)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplicateDecisionTaskStartedEvent provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4, _a5
func (_m *mockMutableState) ReplicateDecisionTaskStartedEvent(_a0 *decisionInfo, _a1 int64, _a2 int64, _a3 int64, _a4 string, _a5 int64) (*decisionInfo, error) {
	ret := _m.Called(_a0, _a1, _a2, _a3, _a4, _a5)

	var r0 *decisionInfo
	if rf, ok := ret.Get(0).(func(*decisionInfo, int64, int64, int64, string, int64) *decisionInfo); ok {
		r0 = rf(_a0, _a1, _a2, _a3, _a4, _a5)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*decisionInfo)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*decisionInfo, int64, int64, int64, string, int64) error); ok {
		r1 = rf(_a0, _a1, _a2, _a3, _a4, _a5)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplicateDecisionTaskTimedOutEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateDecisionTaskTimedOutEvent(_a0 shared.TimeoutType) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(shared.TimeoutType) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateExternalWorkflowExecutionCancelRequested provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateExternalWorkflowExecutionCancelRequested(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateExternalWorkflowExecutionSignaled provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateExternalWorkflowExecutionSignaled(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateRequestCancelExternalWorkflowExecutionFailedEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateRequestCancelExternalWorkflowExecutionFailedEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateRequestCancelExternalWorkflowExecutionInitiatedEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) ReplicateRequestCancelExternalWorkflowExecutionInitiatedEvent(_a0 *shared.HistoryEvent, _a1 string) (*persistence.RequestCancelInfo, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *persistence.RequestCancelInfo
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent, string) *persistence.RequestCancelInfo); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*persistence.RequestCancelInfo)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*shared.HistoryEvent, string) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplicateSignalExternalWorkflowExecutionFailedEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateSignalExternalWorkflowExecutionFailedEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateSignalExternalWorkflowExecutionInitiatedEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) ReplicateSignalExternalWorkflowExecutionInitiatedEvent(_a0 *shared.HistoryEvent, _a1 string) (*persistence.SignalInfo, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *persistence.SignalInfo
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent, string) *persistence.SignalInfo); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*persistence.SignalInfo)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*shared.HistoryEvent, string) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplicateStartChildWorkflowExecutionFailedEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateStartChildWorkflowExecutionFailedEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateStartChildWorkflowExecutionInitiatedEvent provides a mock function with given fields: _a0, _a1, _a2
func (_m *mockMutableState) ReplicateStartChildWorkflowExecutionInitiatedEvent(_a0 int64, _a1 *shared.HistoryEvent, _a2 string) (*persistence.ChildExecutionInfo, error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 *persistence.ChildExecutionInfo
	if rf, ok := ret.Get(0).(func(int64, *shared.HistoryEvent, string) *persistence.ChildExecutionInfo); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*persistence.ChildExecutionInfo)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(int64, *shared.HistoryEvent, string) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplicateTimerCanceledEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateTimerCanceledEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateTimerFiredEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateTimerFiredEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateTimerStartedEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateTimerStartedEvent(_a0 *shared.HistoryEvent) (*persistence.TimerInfo, error) {
	ret := _m.Called(_a0)

	var r0 *persistence.TimerInfo
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) *persistence.TimerInfo); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*persistence.TimerInfo)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*shared.HistoryEvent) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplicateTransientDecisionTaskScheduled provides a mock function with given fields:
func (_m *mockMutableState) ReplicateTransientDecisionTaskScheduled() (*decisionInfo, error) {
	ret := _m.Called()

	var r0 *decisionInfo
	if rf, ok := ret.Get(0).(func() *decisionInfo); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*decisionInfo)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplicateUpsertWorkflowSearchAttributesEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateUpsertWorkflowSearchAttributesEvent(_a0 *shared.HistoryEvent) {
	_m.Called(_a0)
}

// ReplicateWorkflowExecutionCancelRequestedEvent provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateWorkflowExecutionCancelRequestedEvent(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateWorkflowExecutionCanceledEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) ReplicateWorkflowExecutionCanceledEvent(_a0 int64, _a1 *shared.HistoryEvent) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(int64, *shared.HistoryEvent) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateWorkflowExecutionCompletedEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) ReplicateWorkflowExecutionCompletedEvent(_a0 int64, _a1 *shared.HistoryEvent) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(int64, *shared.HistoryEvent) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateWorkflowExecutionContinuedAsNewEvent provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4, _a5, _a6
func (_m *mockMutableState) ReplicateWorkflowExecutionContinuedAsNewEvent(_a0 int64, _a1 string, _a2 *shared.HistoryEvent, _a3 *shared.HistoryEvent, _a4 *decisionInfo, _a5 mutableState, _a6 int32) error {
	ret := _m.Called(_a0, _a1, _a2, _a3, _a4, _a5, _a6)

	var r0 error
	if rf, ok := ret.Get(0).(func(int64, string, *shared.HistoryEvent, *shared.HistoryEvent, *decisionInfo, mutableState, int32) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3, _a4, _a5, _a6)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateWorkflowExecutionFailedEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) ReplicateWorkflowExecutionFailedEvent(_a0 int64, _a1 *shared.HistoryEvent) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(int64, *shared.HistoryEvent) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateWorkflowExecutionSignaled provides a mock function with given fields: _a0
func (_m *mockMutableState) ReplicateWorkflowExecutionSignaled(_a0 *shared.HistoryEvent) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*shared.HistoryEvent) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateWorkflowExecutionStartedEvent provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4
func (_m *mockMutableState) ReplicateWorkflowExecutionStartedEvent(_a0 *cache.DomainCacheEntry, _a1 *string, _a2 shared.WorkflowExecution, _a3 string, _a4 *shared.HistoryEvent) error {
	ret := _m.Called(_a0, _a1, _a2, _a3, _a4)

	var r0 error
	if rf, ok := ret.Get(0).(func(*cache.DomainCacheEntry, *string, shared.WorkflowExecution, string, *shared.HistoryEvent) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3, _a4)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateWorkflowExecutionTerminatedEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) ReplicateWorkflowExecutionTerminatedEvent(_a0 int64, _a1 *shared.HistoryEvent) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(int64, *shared.HistoryEvent) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ReplicateWorkflowExecutionTimedoutEvent provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) ReplicateWorkflowExecutionTimedoutEvent(_a0 int64, _a1 *shared.HistoryEvent) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(int64, *shared.HistoryEvent) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SetHistoryBuilder provides a mock function with given fields: hBuilder
func (_m *mockMutableState) SetHistoryBuilder(hBuilder *historyBuilder) {
	_m.Called(hBuilder)
}

// SetHistoryTree provides a mock function with given fields: treeID
func (_m *mockMutableState) SetHistoryTree(treeID string) error {
	ret := _m.Called(treeID)

	var r0 error
	if rf, ok := ret.Get(0).(func(string) error); ok {
		r0 = rf(treeID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// UpdateActivity provides a mock function with given fields: _a0
func (_m *mockMutableState) UpdateActivity(_a0 *persistence.ActivityInfo) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*persistence.ActivityInfo) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// UpdateActivityProgress provides a mock function with given fields: ai, request
func (_m *mockMutableState) UpdateActivityProgress(ai *persistence.ActivityInfo, request *shared.RecordActivityTaskHeartbeatRequest) {
	_m.Called(ai, request)
}

// UpdateDecision provides a mock function with given fields: _a0
func (_m *mockMutableState) UpdateDecision(_a0 *decisionInfo) {
	_m.Called(_a0)
}

// UpdateReplicationPolicy provides a mock function with given fields: _a0
func (_m *mockMutableState) UpdateReplicationPolicy(_a0 cache.ReplicationPolicy) {
	_m.Called(_a0)
}

// UpdateReplicationStateLastEventID provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) UpdateReplicationStateLastEventID(_a0 int64, _a1 int64) {
	_m.Called(_a0, _a1)
}

// UpdateReplicationStateVersion provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) UpdateReplicationStateVersion(_a0 int64, _a1 bool) {
	_m.Called(_a0, _a1)
}

// UpdateUserTimer provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) UpdateUserTimer(_a0 string, _a1 *persistence.TimerInfo) {
	_m.Called(_a0, _a1)
}

// AddTransferTasks provides a mock function with given fields: _a0
func (_m *mockMutableState) AddTransferTasks(_a0 ...persistence.Task) {
	_m.Called(_a0)
}

// AddTimerTasks provides a mock function with given fields: _a0
func (_m *mockMutableState) AddTimerTasks(_a0 ...persistence.Task) {
	_m.Called(_a0)
}

// SetUpdateCondition provides a mock function with given fields:
func (_m *mockMutableState) SetUpdateCondition(_a0 int64) {
	_m.Called(_a0)
}

// GetUpdateCondition provides a mock function with given fields:
func (_m *mockMutableState) GetUpdateCondition() int64 {
	ret := _m.Called()

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

// CloseTransactionAsMutation provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) CloseTransactionAsMutation(_a0 time.Time, _a1 transactionPolicy) (*persistence.WorkflowMutation, []*persistence.WorkflowEvents, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *persistence.WorkflowMutation
	if rf, ok := ret.Get(0).(func(time.Time, transactionPolicy) *persistence.WorkflowMutation); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*persistence.WorkflowMutation)
		}
	}

	var r1 []*persistence.WorkflowEvents
	if rf, ok := ret.Get(1).(func(time.Time, transactionPolicy) []*persistence.WorkflowEvents); ok {
		r1 = rf(_a0, _a1)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]*persistence.WorkflowEvents)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(time.Time, transactionPolicy) error); ok {
		r2 = rf(_a0, _a1)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// CloseTransactionAsSnapshot provides a mock function with given fields: _a0, _a1
func (_m *mockMutableState) CloseTransactionAsSnapshot(_a0 time.Time, _a1 transactionPolicy) (*persistence.WorkflowSnapshot, []*persistence.WorkflowEvents, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *persistence.WorkflowSnapshot
	if rf, ok := ret.Get(0).(func(time.Time, transactionPolicy) *persistence.WorkflowSnapshot); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*persistence.WorkflowSnapshot)
		}
	}

	var r1 []*persistence.WorkflowEvents
	if rf, ok := ret.Get(1).(func(time.Time, transactionPolicy) []*persistence.WorkflowEvents); ok {
		r1 = rf(_a0, _a1)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]*persistence.WorkflowEvents)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(time.Time, transactionPolicy) error); ok {
		r2 = rf(_a0, _a1)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}