tasks/service/history/workflow/mutable_state_mock.go

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

// Code generated by MockGen. DO NOT EDIT.
// Source: mutable_state.go
//
// Generated by this command:
//
//	mockgen -copyright_file ../../../LICENSE -package workflow -source mutable_state.go -destination mutable_state_mock.go
//

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

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

	nexus "github.com/nexus-rpc/sdk-go/nexus"
	command "go.temporal.io/api/command/v1"
	common "go.temporal.io/api/common/v1"
	deployment "go.temporal.io/api/deployment/v1"
	enums "go.temporal.io/api/enums/v1"
	failure "go.temporal.io/api/failure/v1"
	history "go.temporal.io/api/history/v1"
	taskqueue "go.temporal.io/api/taskqueue/v1"
	update "go.temporal.io/api/update/v1"
	workflow "go.temporal.io/api/workflow/v1"
	workflowservice "go.temporal.io/api/workflowservice/v1"
	clock "go.temporal.io/server/api/clock/v1"
	enums0 "go.temporal.io/server/api/enums/v1"
	history0 "go.temporal.io/server/api/history/v1"
	historyservice "go.temporal.io/server/api/historyservice/v1"
	persistence "go.temporal.io/server/api/persistence/v1"
	taskqueue0 "go.temporal.io/server/api/taskqueue/v1"
	workflow0 "go.temporal.io/server/api/workflow/v1"
	definition "go.temporal.io/server/common/definition"
	namespace "go.temporal.io/server/common/namespace"
	persistence0 "go.temporal.io/server/common/persistence"
	historybuilder "go.temporal.io/server/service/history/historybuilder"
	hsm "go.temporal.io/server/service/history/hsm"
	tasks "go.temporal.io/server/service/history/tasks"
	gomock "go.uber.org/mock/gomock"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

// MockMutableState is a mock of MutableState interface.
type MockMutableState struct {
	ctrl     *gomock.Controller
	recorder *MockMutableStateMockRecorder
}

// MockMutableStateMockRecorder is the mock recorder for MockMutableState.
type MockMutableStateMockRecorder struct {
	mock *MockMutableState
}

// NewMockMutableState creates a new mock instance.
func NewMockMutableState(ctrl *gomock.Controller) *MockMutableState {
	mock := &MockMutableState{ctrl: ctrl}
	mock.recorder = &MockMutableStateMockRecorder{mock}
	return mock
}

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

// AddActivityTaskCancelRequestedEvent mocks base method.
func (m *MockMutableState) AddActivityTaskCancelRequestedEvent(arg0, arg1 int64, arg2 string) (*history.HistoryEvent, *persistence.ActivityInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddActivityTaskCancelRequestedEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(*persistence.ActivityInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddActivityTaskCancelRequestedEvent indicates an expected call of AddActivityTaskCancelRequestedEvent.
func (mr *MockMutableStateMockRecorder) AddActivityTaskCancelRequestedEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddActivityTaskCancelRequestedEvent", reflect.TypeOf((*MockMutableState)(nil).AddActivityTaskCancelRequestedEvent), arg0, arg1, arg2)
}

// AddActivityTaskCanceledEvent mocks base method.
func (m *MockMutableState) AddActivityTaskCanceledEvent(arg0, arg1, arg2 int64, arg3 *common.Payloads, arg4 string) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddActivityTaskCanceledEvent", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddActivityTaskCompletedEvent mocks base method.
func (m *MockMutableState) AddActivityTaskCompletedEvent(arg0, arg1 int64, arg2 *workflowservice.RespondActivityTaskCompletedRequest) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddActivityTaskCompletedEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddActivityTaskCompletedEvent indicates an expected call of AddActivityTaskCompletedEvent.
func (mr *MockMutableStateMockRecorder) AddActivityTaskCompletedEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddActivityTaskCompletedEvent", reflect.TypeOf((*MockMutableState)(nil).AddActivityTaskCompletedEvent), arg0, arg1, arg2)
}

// AddActivityTaskFailedEvent mocks base method.
func (m *MockMutableState) AddActivityTaskFailedEvent(arg0, arg1 int64, arg2 *failure.Failure, arg3 enums.RetryState, arg4 string, arg5 *common.WorkerVersionStamp) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddActivityTaskFailedEvent", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddActivityTaskFailedEvent indicates an expected call of AddActivityTaskFailedEvent.
func (mr *MockMutableStateMockRecorder) AddActivityTaskFailedEvent(arg0, arg1, arg2, arg3, arg4, arg5 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddActivityTaskFailedEvent", reflect.TypeOf((*MockMutableState)(nil).AddActivityTaskFailedEvent), arg0, arg1, arg2, arg3, arg4, arg5)
}

// AddActivityTaskScheduledEvent mocks base method.
func (m *MockMutableState) AddActivityTaskScheduledEvent(arg0 int64, arg1 *command.ScheduleActivityTaskCommandAttributes, arg2 bool) (*history.HistoryEvent, *persistence.ActivityInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddActivityTaskScheduledEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(*persistence.ActivityInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddActivityTaskScheduledEvent indicates an expected call of AddActivityTaskScheduledEvent.
func (mr *MockMutableStateMockRecorder) AddActivityTaskScheduledEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddActivityTaskScheduledEvent", reflect.TypeOf((*MockMutableState)(nil).AddActivityTaskScheduledEvent), arg0, arg1, arg2)
}

// AddActivityTaskStartedEvent mocks base method.
func (m *MockMutableState) AddActivityTaskStartedEvent(arg0 *persistence.ActivityInfo, arg1 int64, arg2, arg3 string, arg4 *common.WorkerVersionStamp, arg5 *deployment.Deployment, arg6 *taskqueue0.BuildIdRedirectInfo) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddActivityTaskStartedEvent", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddActivityTaskStartedEvent indicates an expected call of AddActivityTaskStartedEvent.
func (mr *MockMutableStateMockRecorder) AddActivityTaskStartedEvent(arg0, arg1, arg2, arg3, arg4, arg5, arg6 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddActivityTaskStartedEvent", reflect.TypeOf((*MockMutableState)(nil).AddActivityTaskStartedEvent), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
}

// AddActivityTaskTimedOutEvent mocks base method.
func (m *MockMutableState) AddActivityTaskTimedOutEvent(arg0, arg1 int64, arg2 *failure.Failure, arg3 enums.RetryState) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddActivityTaskTimedOutEvent", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddActivityTaskTimedOutEvent indicates an expected call of AddActivityTaskTimedOutEvent.
func (mr *MockMutableStateMockRecorder) AddActivityTaskTimedOutEvent(arg0, arg1, arg2, arg3 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddActivityTaskTimedOutEvent", reflect.TypeOf((*MockMutableState)(nil).AddActivityTaskTimedOutEvent), arg0, arg1, arg2, arg3)
}

// AddChildWorkflowExecutionCanceledEvent mocks base method.
func (m *MockMutableState) AddChildWorkflowExecutionCanceledEvent(arg0 int64, arg1 *common.WorkflowExecution, arg2 *history.WorkflowExecutionCanceledEventAttributes) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddChildWorkflowExecutionCanceledEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddChildWorkflowExecutionCanceledEvent indicates an expected call of AddChildWorkflowExecutionCanceledEvent.
func (mr *MockMutableStateMockRecorder) AddChildWorkflowExecutionCanceledEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddChildWorkflowExecutionCanceledEvent", reflect.TypeOf((*MockMutableState)(nil).AddChildWorkflowExecutionCanceledEvent), arg0, arg1, arg2)
}

// AddChildWorkflowExecutionCompletedEvent mocks base method.
func (m *MockMutableState) AddChildWorkflowExecutionCompletedEvent(arg0 int64, arg1 *common.WorkflowExecution, arg2 *history.WorkflowExecutionCompletedEventAttributes) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddChildWorkflowExecutionCompletedEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddChildWorkflowExecutionCompletedEvent indicates an expected call of AddChildWorkflowExecutionCompletedEvent.
func (mr *MockMutableStateMockRecorder) AddChildWorkflowExecutionCompletedEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddChildWorkflowExecutionCompletedEvent", reflect.TypeOf((*MockMutableState)(nil).AddChildWorkflowExecutionCompletedEvent), arg0, arg1, arg2)
}

// AddChildWorkflowExecutionFailedEvent mocks base method.
func (m *MockMutableState) AddChildWorkflowExecutionFailedEvent(arg0 int64, arg1 *common.WorkflowExecution, arg2 *history.WorkflowExecutionFailedEventAttributes) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddChildWorkflowExecutionFailedEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddChildWorkflowExecutionFailedEvent indicates an expected call of AddChildWorkflowExecutionFailedEvent.
func (mr *MockMutableStateMockRecorder) AddChildWorkflowExecutionFailedEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddChildWorkflowExecutionFailedEvent", reflect.TypeOf((*MockMutableState)(nil).AddChildWorkflowExecutionFailedEvent), arg0, arg1, arg2)
}

// AddChildWorkflowExecutionStartedEvent mocks base method.
func (m *MockMutableState) AddChildWorkflowExecutionStartedEvent(arg0 *common.WorkflowExecution, arg1 *common.WorkflowType, arg2 int64, arg3 *common.Header, arg4 *clock.VectorClock) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddChildWorkflowExecutionStartedEvent", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddChildWorkflowExecutionTerminatedEvent mocks base method.
func (m *MockMutableState) AddChildWorkflowExecutionTerminatedEvent(arg0 int64, arg1 *common.WorkflowExecution, arg2 *history.WorkflowExecutionTerminatedEventAttributes) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddChildWorkflowExecutionTerminatedEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddChildWorkflowExecutionTerminatedEvent indicates an expected call of AddChildWorkflowExecutionTerminatedEvent.
func (mr *MockMutableStateMockRecorder) AddChildWorkflowExecutionTerminatedEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddChildWorkflowExecutionTerminatedEvent", reflect.TypeOf((*MockMutableState)(nil).AddChildWorkflowExecutionTerminatedEvent), arg0, arg1, arg2)
}

// AddChildWorkflowExecutionTimedOutEvent mocks base method.
func (m *MockMutableState) AddChildWorkflowExecutionTimedOutEvent(arg0 int64, arg1 *common.WorkflowExecution, arg2 *history.WorkflowExecutionTimedOutEventAttributes) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddChildWorkflowExecutionTimedOutEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddChildWorkflowExecutionTimedOutEvent indicates an expected call of AddChildWorkflowExecutionTimedOutEvent.
func (mr *MockMutableStateMockRecorder) AddChildWorkflowExecutionTimedOutEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddChildWorkflowExecutionTimedOutEvent", reflect.TypeOf((*MockMutableState)(nil).AddChildWorkflowExecutionTimedOutEvent), arg0, arg1, arg2)
}

// AddCompletedWorkflowEvent mocks base method.
func (m *MockMutableState) AddCompletedWorkflowEvent(arg0 int64, arg1 *command.CompleteWorkflowExecutionCommandAttributes, arg2 string) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddCompletedWorkflowEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddCompletedWorkflowEvent indicates an expected call of AddCompletedWorkflowEvent.
func (mr *MockMutableStateMockRecorder) AddCompletedWorkflowEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCompletedWorkflowEvent", reflect.TypeOf((*MockMutableState)(nil).AddCompletedWorkflowEvent), arg0, arg1, arg2)
}

// AddContinueAsNewEvent mocks base method.
func (m *MockMutableState) AddContinueAsNewEvent(arg0 context.Context, arg1, arg2 int64, arg3 namespace.Name, arg4 *command.ContinueAsNewWorkflowExecutionCommandAttributes) (*history.HistoryEvent, MutableState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddContinueAsNewEvent", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(MutableState)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// AddExternalWorkflowExecutionCancelRequested mocks base method.
func (m *MockMutableState) AddExternalWorkflowExecutionCancelRequested(arg0 int64, arg1 namespace.Name, arg2 namespace.ID, arg3, arg4 string) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddExternalWorkflowExecutionCancelRequested", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddExternalWorkflowExecutionSignaled mocks base method.
func (m *MockMutableState) AddExternalWorkflowExecutionSignaled(arg0 int64, arg1 namespace.Name, arg2 namespace.ID, arg3, arg4, arg5 string) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddExternalWorkflowExecutionSignaled", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddExternalWorkflowExecutionSignaled indicates an expected call of AddExternalWorkflowExecutionSignaled.
func (mr *MockMutableStateMockRecorder) AddExternalWorkflowExecutionSignaled(arg0, arg1, arg2, arg3, arg4, arg5 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddExternalWorkflowExecutionSignaled", reflect.TypeOf((*MockMutableState)(nil).AddExternalWorkflowExecutionSignaled), arg0, arg1, arg2, arg3, arg4, arg5)
}

// AddFailWorkflowEvent mocks base method.
func (m *MockMutableState) AddFailWorkflowEvent(arg0 int64, arg1 enums.RetryState, arg2 *command.FailWorkflowExecutionCommandAttributes, arg3 string) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddFailWorkflowEvent", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddFailWorkflowEvent indicates an expected call of AddFailWorkflowEvent.
func (mr *MockMutableStateMockRecorder) AddFailWorkflowEvent(arg0, arg1, arg2, arg3 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFailWorkflowEvent", reflect.TypeOf((*MockMutableState)(nil).AddFailWorkflowEvent), arg0, arg1, arg2, arg3)
}

// AddFirstWorkflowTaskScheduled mocks base method.
func (m *MockMutableState) AddFirstWorkflowTaskScheduled(parentClock *clock.VectorClock, event *history.HistoryEvent, bypassTaskGeneration bool) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddFirstWorkflowTaskScheduled", parentClock, event, bypassTaskGeneration)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddFirstWorkflowTaskScheduled indicates an expected call of AddFirstWorkflowTaskScheduled.
func (mr *MockMutableStateMockRecorder) AddFirstWorkflowTaskScheduled(parentClock, event, bypassTaskGeneration any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFirstWorkflowTaskScheduled", reflect.TypeOf((*MockMutableState)(nil).AddFirstWorkflowTaskScheduled), parentClock, event, bypassTaskGeneration)
}

// AddHistoryEvent mocks base method.
func (m *MockMutableState) AddHistoryEvent(t enums.EventType, setAttributes func(*history.HistoryEvent)) *history.HistoryEvent {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddHistoryEvent", t, setAttributes)
	ret0, _ := ret[0].(*history.HistoryEvent)
	return ret0
}

// AddHistoryEvent indicates an expected call of AddHistoryEvent.
func (mr *MockMutableStateMockRecorder) AddHistoryEvent(t, setAttributes any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHistoryEvent", reflect.TypeOf((*MockMutableState)(nil).AddHistoryEvent), t, setAttributes)
}

// AddHistorySize mocks base method.
func (m *MockMutableState) AddHistorySize(size int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddHistorySize", size)
}

// AddHistorySize indicates an expected call of AddHistorySize.
func (mr *MockMutableStateMockRecorder) AddHistorySize(size any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHistorySize", reflect.TypeOf((*MockMutableState)(nil).AddHistorySize), size)
}

// AddRecordMarkerEvent mocks base method.
func (m *MockMutableState) AddRecordMarkerEvent(arg0 int64, arg1 *command.RecordMarkerCommandAttributes) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddRecordMarkerEvent", arg0, arg1)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddRequestCancelExternalWorkflowExecutionFailedEvent mocks base method.
func (m *MockMutableState) AddRequestCancelExternalWorkflowExecutionFailedEvent(arg0 int64, arg1 namespace.Name, arg2 namespace.ID, arg3, arg4 string, arg5 enums.CancelExternalWorkflowExecutionFailedCause) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddRequestCancelExternalWorkflowExecutionFailedEvent", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddRequestCancelExternalWorkflowExecutionFailedEvent indicates an expected call of AddRequestCancelExternalWorkflowExecutionFailedEvent.
func (mr *MockMutableStateMockRecorder) AddRequestCancelExternalWorkflowExecutionFailedEvent(arg0, arg1, arg2, arg3, arg4, arg5 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRequestCancelExternalWorkflowExecutionFailedEvent", reflect.TypeOf((*MockMutableState)(nil).AddRequestCancelExternalWorkflowExecutionFailedEvent), arg0, arg1, arg2, arg3, arg4, arg5)
}

// AddRequestCancelExternalWorkflowExecutionInitiatedEvent mocks base method.
func (m *MockMutableState) AddRequestCancelExternalWorkflowExecutionInitiatedEvent(arg0 int64, arg1 string, arg2 *command.RequestCancelExternalWorkflowExecutionCommandAttributes, arg3 namespace.ID) (*history.HistoryEvent, *persistence.RequestCancelInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddRequestCancelExternalWorkflowExecutionInitiatedEvent", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(*persistence.RequestCancelInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddRequestCancelExternalWorkflowExecutionInitiatedEvent indicates an expected call of AddRequestCancelExternalWorkflowExecutionInitiatedEvent.
func (mr *MockMutableStateMockRecorder) AddRequestCancelExternalWorkflowExecutionInitiatedEvent(arg0, arg1, arg2, arg3 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRequestCancelExternalWorkflowExecutionInitiatedEvent", reflect.TypeOf((*MockMutableState)(nil).AddRequestCancelExternalWorkflowExecutionInitiatedEvent), arg0, arg1, arg2, arg3)
}

// AddSignalExternalWorkflowExecutionFailedEvent mocks base method.
func (m *MockMutableState) AddSignalExternalWorkflowExecutionFailedEvent(arg0 int64, arg1 namespace.Name, arg2 namespace.ID, arg3, arg4, arg5 string, arg6 enums.SignalExternalWorkflowExecutionFailedCause) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSignalExternalWorkflowExecutionFailedEvent", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddSignalExternalWorkflowExecutionFailedEvent indicates an expected call of AddSignalExternalWorkflowExecutionFailedEvent.
func (mr *MockMutableStateMockRecorder) AddSignalExternalWorkflowExecutionFailedEvent(arg0, arg1, arg2, arg3, arg4, arg5, arg6 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSignalExternalWorkflowExecutionFailedEvent", reflect.TypeOf((*MockMutableState)(nil).AddSignalExternalWorkflowExecutionFailedEvent), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
}

// AddSignalExternalWorkflowExecutionInitiatedEvent mocks base method.
func (m *MockMutableState) AddSignalExternalWorkflowExecutionInitiatedEvent(arg0 int64, arg1 string, arg2 *command.SignalExternalWorkflowExecutionCommandAttributes, arg3 namespace.ID) (*history.HistoryEvent, *persistence.SignalInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSignalExternalWorkflowExecutionInitiatedEvent", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(*persistence.SignalInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddSignalExternalWorkflowExecutionInitiatedEvent indicates an expected call of AddSignalExternalWorkflowExecutionInitiatedEvent.
func (mr *MockMutableStateMockRecorder) AddSignalExternalWorkflowExecutionInitiatedEvent(arg0, arg1, arg2, arg3 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSignalExternalWorkflowExecutionInitiatedEvent", reflect.TypeOf((*MockMutableState)(nil).AddSignalExternalWorkflowExecutionInitiatedEvent), arg0, arg1, arg2, arg3)
}

// AddSignalRequested mocks base method.
func (m *MockMutableState) AddSignalRequested(requestID string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddSignalRequested", requestID)
}

// AddSignalRequested indicates an expected call of AddSignalRequested.
func (mr *MockMutableStateMockRecorder) AddSignalRequested(requestID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSignalRequested", reflect.TypeOf((*MockMutableState)(nil).AddSignalRequested), requestID)
}

// AddStartChildWorkflowExecutionFailedEvent mocks base method.
func (m *MockMutableState) AddStartChildWorkflowExecutionFailedEvent(arg0 int64, arg1 enums.StartChildWorkflowExecutionFailedCause, arg2 *history.StartChildWorkflowExecutionInitiatedEventAttributes) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddStartChildWorkflowExecutionFailedEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddStartChildWorkflowExecutionFailedEvent indicates an expected call of AddStartChildWorkflowExecutionFailedEvent.
func (mr *MockMutableStateMockRecorder) AddStartChildWorkflowExecutionFailedEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddStartChildWorkflowExecutionFailedEvent", reflect.TypeOf((*MockMutableState)(nil).AddStartChildWorkflowExecutionFailedEvent), arg0, arg1, arg2)
}

// AddStartChildWorkflowExecutionInitiatedEvent mocks base method.
func (m *MockMutableState) AddStartChildWorkflowExecutionInitiatedEvent(arg0 int64, arg1 string, arg2 *command.StartChildWorkflowExecutionCommandAttributes, arg3 namespace.ID) (*history.HistoryEvent, *persistence.ChildExecutionInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddStartChildWorkflowExecutionInitiatedEvent", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(*persistence.ChildExecutionInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddStartChildWorkflowExecutionInitiatedEvent indicates an expected call of AddStartChildWorkflowExecutionInitiatedEvent.
func (mr *MockMutableStateMockRecorder) AddStartChildWorkflowExecutionInitiatedEvent(arg0, arg1, arg2, arg3 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddStartChildWorkflowExecutionInitiatedEvent", reflect.TypeOf((*MockMutableState)(nil).AddStartChildWorkflowExecutionInitiatedEvent), arg0, arg1, arg2, arg3)
}

// AddTasks mocks base method.
func (m *MockMutableState) AddTasks(tasks ...tasks.Task) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range tasks {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "AddTasks", varargs...)
}

// AddTasks indicates an expected call of AddTasks.
func (mr *MockMutableStateMockRecorder) AddTasks(tasks ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTasks", reflect.TypeOf((*MockMutableState)(nil).AddTasks), tasks...)
}

// AddTimeoutWorkflowEvent mocks base method.
func (m *MockMutableState) AddTimeoutWorkflowEvent(arg0 int64, arg1 enums.RetryState, arg2 string) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTimeoutWorkflowEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddTimeoutWorkflowEvent indicates an expected call of AddTimeoutWorkflowEvent.
func (mr *MockMutableStateMockRecorder) AddTimeoutWorkflowEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTimeoutWorkflowEvent", reflect.TypeOf((*MockMutableState)(nil).AddTimeoutWorkflowEvent), arg0, arg1, arg2)
}

// AddTimerCanceledEvent mocks base method.
func (m *MockMutableState) AddTimerCanceledEvent(arg0 int64, arg1 *command.CancelTimerCommandAttributes, arg2 string) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTimerCanceledEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddTimerCanceledEvent indicates an expected call of AddTimerCanceledEvent.
func (mr *MockMutableStateMockRecorder) AddTimerCanceledEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTimerCanceledEvent", reflect.TypeOf((*MockMutableState)(nil).AddTimerCanceledEvent), arg0, arg1, arg2)
}

// AddTimerFiredEvent mocks base method.
func (m *MockMutableState) AddTimerFiredEvent(arg0 string) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTimerFiredEvent", arg0)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddTimerStartedEvent mocks base method.
func (m *MockMutableState) AddTimerStartedEvent(arg0 int64, arg1 *command.StartTimerCommandAttributes) (*history.HistoryEvent, *persistence.TimerInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTimerStartedEvent", arg0, arg1)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(*persistence.TimerInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// AddUpsertWorkflowSearchAttributesEvent mocks base method.
func (m *MockMutableState) AddUpsertWorkflowSearchAttributesEvent(arg0 int64, arg1 *command.UpsertWorkflowSearchAttributesCommandAttributes) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddUpsertWorkflowSearchAttributesEvent", arg0, arg1)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddWorkflowExecutionCancelRequestedEvent mocks base method.
func (m *MockMutableState) AddWorkflowExecutionCancelRequestedEvent(arg0 *historyservice.RequestCancelWorkflowExecutionRequest) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowExecutionCancelRequestedEvent", arg0)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddWorkflowExecutionCanceledEvent mocks base method.
func (m *MockMutableState) AddWorkflowExecutionCanceledEvent(arg0 int64, arg1 *command.CancelWorkflowExecutionCommandAttributes) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowExecutionCanceledEvent", arg0, arg1)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddWorkflowExecutionOptionsUpdatedEvent mocks base method.
func (m *MockMutableState) AddWorkflowExecutionOptionsUpdatedEvent(versioningOverride *workflow.VersioningOverride) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowExecutionOptionsUpdatedEvent", versioningOverride)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddWorkflowExecutionOptionsUpdatedEvent indicates an expected call of AddWorkflowExecutionOptionsUpdatedEvent.
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionOptionsUpdatedEvent(versioningOverride any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionOptionsUpdatedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionOptionsUpdatedEvent), versioningOverride)
}

// AddWorkflowExecutionSignaled mocks base method.
func (m *MockMutableState) AddWorkflowExecutionSignaled(signalName string, input *common.Payloads, identity string, header *common.Header, links []*common.Link) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowExecutionSignaled", signalName, input, identity, header, links)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddWorkflowExecutionSignaled indicates an expected call of AddWorkflowExecutionSignaled.
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionSignaled(signalName, input, identity, header, links any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionSignaled", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionSignaled), signalName, input, identity, header, links)
}

// AddWorkflowExecutionSignaledEvent mocks base method.
func (m *MockMutableState) AddWorkflowExecutionSignaledEvent(signalName string, input *common.Payloads, identity string, header *common.Header, externalWorkflowExecution *common.WorkflowExecution, links []*common.Link) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowExecutionSignaledEvent", signalName, input, identity, header, externalWorkflowExecution, links)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddWorkflowExecutionSignaledEvent indicates an expected call of AddWorkflowExecutionSignaledEvent.
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionSignaledEvent(signalName, input, identity, header, externalWorkflowExecution, links any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionSignaledEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionSignaledEvent), signalName, input, identity, header, externalWorkflowExecution, links)
}

// AddWorkflowExecutionStartedEvent mocks base method.
func (m *MockMutableState) AddWorkflowExecutionStartedEvent(arg0 *common.WorkflowExecution, arg1 *historyservice.StartWorkflowExecutionRequest) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowExecutionStartedEvent", arg0, arg1)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddWorkflowExecutionStartedEventWithOptions mocks base method.
func (m *MockMutableState) AddWorkflowExecutionStartedEventWithOptions(arg0 *common.WorkflowExecution, arg1 *historyservice.StartWorkflowExecutionRequest, arg2 *workflow.ResetPoints, arg3, arg4 string) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowExecutionStartedEventWithOptions", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddWorkflowExecutionTerminatedEvent mocks base method.
func (m *MockMutableState) AddWorkflowExecutionTerminatedEvent(firstEventID int64, reason string, details *common.Payloads, identity string, deleteAfterTerminate bool, links []*common.Link) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowExecutionTerminatedEvent", firstEventID, reason, details, identity, deleteAfterTerminate, links)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddWorkflowExecutionTerminatedEvent indicates an expected call of AddWorkflowExecutionTerminatedEvent.
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionTerminatedEvent(firstEventID, reason, details, identity, deleteAfterTerminate, links any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionTerminatedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionTerminatedEvent), firstEventID, reason, details, identity, deleteAfterTerminate, links)
}

// AddWorkflowExecutionUpdateAcceptedEvent mocks base method.
func (m *MockMutableState) AddWorkflowExecutionUpdateAcceptedEvent(protocolInstanceID, acceptedRequestMessageId string, acceptedRequestSequencingEventId int64, acceptedRequest *update.Request) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowExecutionUpdateAcceptedEvent", protocolInstanceID, acceptedRequestMessageId, acceptedRequestSequencingEventId, acceptedRequest)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddWorkflowExecutionUpdateAcceptedEvent indicates an expected call of AddWorkflowExecutionUpdateAcceptedEvent.
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionUpdateAcceptedEvent(protocolInstanceID, acceptedRequestMessageId, acceptedRequestSequencingEventId, acceptedRequest any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionUpdateAcceptedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionUpdateAcceptedEvent), protocolInstanceID, acceptedRequestMessageId, acceptedRequestSequencingEventId, acceptedRequest)
}

// AddWorkflowExecutionUpdateAdmittedEvent mocks base method.
func (m *MockMutableState) AddWorkflowExecutionUpdateAdmittedEvent(request *update.Request, origin enums.UpdateAdmittedEventOrigin) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowExecutionUpdateAdmittedEvent", request, origin)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddWorkflowExecutionUpdateAdmittedEvent indicates an expected call of AddWorkflowExecutionUpdateAdmittedEvent.
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionUpdateAdmittedEvent(request, origin any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionUpdateAdmittedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionUpdateAdmittedEvent), request, origin)
}

// AddWorkflowExecutionUpdateCompletedEvent mocks base method.
func (m *MockMutableState) AddWorkflowExecutionUpdateCompletedEvent(acceptedEventID int64, updResp *update.Response) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowExecutionUpdateCompletedEvent", acceptedEventID, updResp)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddWorkflowExecutionUpdateCompletedEvent indicates an expected call of AddWorkflowExecutionUpdateCompletedEvent.
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionUpdateCompletedEvent(acceptedEventID, updResp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionUpdateCompletedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionUpdateCompletedEvent), acceptedEventID, updResp)
}

// AddWorkflowPropertiesModifiedEvent mocks base method.
func (m *MockMutableState) AddWorkflowPropertiesModifiedEvent(arg0 int64, arg1 *command.ModifyWorkflowPropertiesCommandAttributes) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowPropertiesModifiedEvent", arg0, arg1)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddWorkflowTaskCompletedEvent mocks base method.
func (m *MockMutableState) AddWorkflowTaskCompletedEvent(arg0 *WorkflowTaskInfo, arg1 *workflowservice.RespondWorkflowTaskCompletedRequest, arg2 WorkflowTaskCompletionLimits) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowTaskCompletedEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddWorkflowTaskCompletedEvent indicates an expected call of AddWorkflowTaskCompletedEvent.
func (mr *MockMutableStateMockRecorder) AddWorkflowTaskCompletedEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowTaskCompletedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowTaskCompletedEvent), arg0, arg1, arg2)
}

// AddWorkflowTaskFailedEvent mocks base method.
func (m *MockMutableState) AddWorkflowTaskFailedEvent(workflowTask *WorkflowTaskInfo, cause enums.WorkflowTaskFailedCause, failure *failure.Failure, identity string, versioningStamp *common.WorkerVersionStamp, binChecksum, baseRunID, newRunID string, forkEventVersion int64) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowTaskFailedEvent", workflowTask, cause, failure, identity, versioningStamp, binChecksum, baseRunID, newRunID, forkEventVersion)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddWorkflowTaskFailedEvent indicates an expected call of AddWorkflowTaskFailedEvent.
func (mr *MockMutableStateMockRecorder) AddWorkflowTaskFailedEvent(workflowTask, cause, failure, identity, versioningStamp, binChecksum, baseRunID, newRunID, forkEventVersion any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowTaskFailedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowTaskFailedEvent), workflowTask, cause, failure, identity, versioningStamp, binChecksum, baseRunID, newRunID, forkEventVersion)
}

// AddWorkflowTaskScheduleToStartTimeoutEvent mocks base method.
func (m *MockMutableState) AddWorkflowTaskScheduleToStartTimeoutEvent(workflowTask *WorkflowTaskInfo) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowTaskScheduleToStartTimeoutEvent", workflowTask)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddWorkflowTaskScheduleToStartTimeoutEvent indicates an expected call of AddWorkflowTaskScheduleToStartTimeoutEvent.
func (mr *MockMutableStateMockRecorder) AddWorkflowTaskScheduleToStartTimeoutEvent(workflowTask any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowTaskScheduleToStartTimeoutEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowTaskScheduleToStartTimeoutEvent), workflowTask)
}

// AddWorkflowTaskScheduledEvent mocks base method.
func (m *MockMutableState) AddWorkflowTaskScheduledEvent(bypassTaskGeneration bool, workflowTaskType enums0.WorkflowTaskType) (*WorkflowTaskInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowTaskScheduledEvent", bypassTaskGeneration, workflowTaskType)
	ret0, _ := ret[0].(*WorkflowTaskInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddWorkflowTaskScheduledEvent indicates an expected call of AddWorkflowTaskScheduledEvent.
func (mr *MockMutableStateMockRecorder) AddWorkflowTaskScheduledEvent(bypassTaskGeneration, workflowTaskType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowTaskScheduledEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowTaskScheduledEvent), bypassTaskGeneration, workflowTaskType)
}

// AddWorkflowTaskScheduledEventAsHeartbeat mocks base method.
func (m *MockMutableState) AddWorkflowTaskScheduledEventAsHeartbeat(bypassTaskGeneration bool, originalScheduledTimestamp *timestamppb.Timestamp, workflowTaskType enums0.WorkflowTaskType) (*WorkflowTaskInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowTaskScheduledEventAsHeartbeat", bypassTaskGeneration, originalScheduledTimestamp, workflowTaskType)
	ret0, _ := ret[0].(*WorkflowTaskInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddWorkflowTaskScheduledEventAsHeartbeat indicates an expected call of AddWorkflowTaskScheduledEventAsHeartbeat.
func (mr *MockMutableStateMockRecorder) AddWorkflowTaskScheduledEventAsHeartbeat(bypassTaskGeneration, originalScheduledTimestamp, workflowTaskType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowTaskScheduledEventAsHeartbeat", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowTaskScheduledEventAsHeartbeat), bypassTaskGeneration, originalScheduledTimestamp, workflowTaskType)
}

// AddWorkflowTaskStartedEvent mocks base method.
func (m *MockMutableState) AddWorkflowTaskStartedEvent(arg0 int64, arg1 string, arg2 *taskqueue.TaskQueue, arg3 string, arg4 *common.WorkerVersionStamp, arg5 *taskqueue0.BuildIdRedirectInfo, arg6 bool) (*history.HistoryEvent, *WorkflowTaskInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowTaskStartedEvent", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(*WorkflowTaskInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddWorkflowTaskStartedEvent indicates an expected call of AddWorkflowTaskStartedEvent.
func (mr *MockMutableStateMockRecorder) AddWorkflowTaskStartedEvent(arg0, arg1, arg2, arg3, arg4, arg5, arg6 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowTaskStartedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowTaskStartedEvent), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
}

// AddWorkflowTaskTimedOutEvent mocks base method.
func (m *MockMutableState) AddWorkflowTaskTimedOutEvent(workflowTask *WorkflowTaskInfo) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowTaskTimedOutEvent", workflowTask)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddWorkflowTaskTimedOutEvent indicates an expected call of AddWorkflowTaskTimedOutEvent.
func (mr *MockMutableStateMockRecorder) AddWorkflowTaskTimedOutEvent(workflowTask any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowTaskTimedOutEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowTaskTimedOutEvent), workflowTask)
}

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

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

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

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

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

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

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

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

// ApplyActivityTaskScheduledEvent mocks base method.
func (m *MockMutableState) ApplyActivityTaskScheduledEvent(arg0 int64, arg1 *history.HistoryEvent) (*persistence.ActivityInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyActivityTaskScheduledEvent", arg0, arg1)
	ret0, _ := ret[0].(*persistence.ActivityInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// ApplyBuildIdRedirect mocks base method.
func (m *MockMutableState) ApplyBuildIdRedirect(startingTaskScheduledEventId int64, buildId string, redirectCounter int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyBuildIdRedirect", startingTaskScheduledEventId, buildId, redirectCounter)
	ret0, _ := ret[0].(error)
	return ret0
}

// ApplyBuildIdRedirect indicates an expected call of ApplyBuildIdRedirect.
func (mr *MockMutableStateMockRecorder) ApplyBuildIdRedirect(startingTaskScheduledEventId, buildId, redirectCounter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyBuildIdRedirect", reflect.TypeOf((*MockMutableState)(nil).ApplyBuildIdRedirect), startingTaskScheduledEventId, buildId, redirectCounter)
}

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

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

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

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

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

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

// ApplyChildWorkflowExecutionStartedEvent mocks base method.
func (m *MockMutableState) ApplyChildWorkflowExecutionStartedEvent(arg0 *history.HistoryEvent, arg1 *clock.VectorClock) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyChildWorkflowExecutionStartedEvent", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

// ApplyMutation indicates an expected call of ApplyMutation.
func (mr *MockMutableStateMockRecorder) ApplyMutation(mutation any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyMutation", reflect.TypeOf((*MockMutableState)(nil).ApplyMutation), mutation)
}

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

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

// ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent mocks base method.
func (m *MockMutableState) ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent(arg0 int64, arg1 *history.HistoryEvent, arg2 string) (*persistence.RequestCancelInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*persistence.RequestCancelInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent indicates an expected call of ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent.
func (mr *MockMutableStateMockRecorder) ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent), arg0, arg1, arg2)
}

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

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

// ApplySignalExternalWorkflowExecutionInitiatedEvent mocks base method.
func (m *MockMutableState) ApplySignalExternalWorkflowExecutionInitiatedEvent(arg0 int64, arg1 *history.HistoryEvent, arg2 string) (*persistence.SignalInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplySignalExternalWorkflowExecutionInitiatedEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*persistence.SignalInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApplySignalExternalWorkflowExecutionInitiatedEvent indicates an expected call of ApplySignalExternalWorkflowExecutionInitiatedEvent.
func (mr *MockMutableStateMockRecorder) ApplySignalExternalWorkflowExecutionInitiatedEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySignalExternalWorkflowExecutionInitiatedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplySignalExternalWorkflowExecutionInitiatedEvent), arg0, arg1, arg2)
}

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

// ApplySnapshot indicates an expected call of ApplySnapshot.
func (mr *MockMutableStateMockRecorder) ApplySnapshot(snapshot any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySnapshot", reflect.TypeOf((*MockMutableState)(nil).ApplySnapshot), snapshot)
}

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

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

// ApplyStartChildWorkflowExecutionInitiatedEvent mocks base method.
func (m *MockMutableState) ApplyStartChildWorkflowExecutionInitiatedEvent(arg0 int64, arg1 *history.HistoryEvent, arg2 string) (*persistence.ChildExecutionInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyStartChildWorkflowExecutionInitiatedEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(*persistence.ChildExecutionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApplyStartChildWorkflowExecutionInitiatedEvent indicates an expected call of ApplyStartChildWorkflowExecutionInitiatedEvent.
func (mr *MockMutableStateMockRecorder) ApplyStartChildWorkflowExecutionInitiatedEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyStartChildWorkflowExecutionInitiatedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyStartChildWorkflowExecutionInitiatedEvent), arg0, arg1, arg2)
}

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

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

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

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

// ApplyTimerStartedEvent mocks base method.
func (m *MockMutableState) ApplyTimerStartedEvent(arg0 *history.HistoryEvent) (*persistence.TimerInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyTimerStartedEvent", arg0)
	ret0, _ := ret[0].(*persistence.TimerInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ApplyUpsertWorkflowSearchAttributesEvent mocks base method.
func (m *MockMutableState) ApplyUpsertWorkflowSearchAttributesEvent(arg0 *history.HistoryEvent) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ApplyUpsertWorkflowSearchAttributesEvent", arg0)
}

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

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

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

// ApplyWorkflowExecutionCanceledEvent mocks base method.
func (m *MockMutableState) ApplyWorkflowExecutionCanceledEvent(arg0 int64, arg1 *history.HistoryEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyWorkflowExecutionCanceledEvent", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ApplyWorkflowExecutionCompletedEvent mocks base method.
func (m *MockMutableState) ApplyWorkflowExecutionCompletedEvent(arg0 int64, arg1 *history.HistoryEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyWorkflowExecutionCompletedEvent", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ApplyWorkflowExecutionContinuedAsNewEvent mocks base method.
func (m *MockMutableState) ApplyWorkflowExecutionContinuedAsNewEvent(arg0 int64, arg1 *history.HistoryEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyWorkflowExecutionContinuedAsNewEvent", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ApplyWorkflowExecutionFailedEvent mocks base method.
func (m *MockMutableState) ApplyWorkflowExecutionFailedEvent(arg0 int64, arg1 *history.HistoryEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyWorkflowExecutionFailedEvent", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

// ApplyWorkflowExecutionOptionsUpdatedEvent indicates an expected call of ApplyWorkflowExecutionOptionsUpdatedEvent.
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionOptionsUpdatedEvent(event any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionOptionsUpdatedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionOptionsUpdatedEvent), event)
}

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

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

// ApplyWorkflowExecutionStartedEvent mocks base method.
func (m *MockMutableState) ApplyWorkflowExecutionStartedEvent(arg0 *clock.VectorClock, arg1 *common.WorkflowExecution, arg2 string, arg3 *history.HistoryEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyWorkflowExecutionStartedEvent", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// ApplyWorkflowExecutionStartedEvent indicates an expected call of ApplyWorkflowExecutionStartedEvent.
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionStartedEvent(arg0, arg1, arg2, arg3 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionStartedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionStartedEvent), arg0, arg1, arg2, arg3)
}

// ApplyWorkflowExecutionTerminatedEvent mocks base method.
func (m *MockMutableState) ApplyWorkflowExecutionTerminatedEvent(arg0 int64, arg1 *history.HistoryEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyWorkflowExecutionTerminatedEvent", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ApplyWorkflowExecutionTimedoutEvent mocks base method.
func (m *MockMutableState) ApplyWorkflowExecutionTimedoutEvent(arg0 int64, arg1 *history.HistoryEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyWorkflowExecutionTimedoutEvent", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// ApplyWorkflowExecutionUpdateAdmittedEvent mocks base method.
func (m *MockMutableState) ApplyWorkflowExecutionUpdateAdmittedEvent(event *history.HistoryEvent, batchId int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyWorkflowExecutionUpdateAdmittedEvent", event, batchId)
	ret0, _ := ret[0].(error)
	return ret0
}

// ApplyWorkflowExecutionUpdateAdmittedEvent indicates an expected call of ApplyWorkflowExecutionUpdateAdmittedEvent.
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionUpdateAdmittedEvent(event, batchId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionUpdateAdmittedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionUpdateAdmittedEvent), event, batchId)
}

// ApplyWorkflowExecutionUpdateCompletedEvent mocks base method.
func (m *MockMutableState) ApplyWorkflowExecutionUpdateCompletedEvent(event *history.HistoryEvent, batchID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyWorkflowExecutionUpdateCompletedEvent", event, batchID)
	ret0, _ := ret[0].(error)
	return ret0
}

// ApplyWorkflowExecutionUpdateCompletedEvent indicates an expected call of ApplyWorkflowExecutionUpdateCompletedEvent.
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionUpdateCompletedEvent(event, batchID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionUpdateCompletedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionUpdateCompletedEvent), event, batchID)
}

// ApplyWorkflowPropertiesModifiedEvent mocks base method.
func (m *MockMutableState) ApplyWorkflowPropertiesModifiedEvent(arg0 *history.HistoryEvent) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ApplyWorkflowPropertiesModifiedEvent", arg0)
}

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

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

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

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

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

// ApplyWorkflowTaskScheduledEvent mocks base method.
func (m *MockMutableState) ApplyWorkflowTaskScheduledEvent(arg0, arg1 int64, arg2 *taskqueue.TaskQueue, arg3 *durationpb.Duration, arg4 int32, arg5, arg6 *timestamppb.Timestamp, arg7 enums0.WorkflowTaskType) (*WorkflowTaskInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyWorkflowTaskScheduledEvent", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
	ret0, _ := ret[0].(*WorkflowTaskInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApplyWorkflowTaskScheduledEvent indicates an expected call of ApplyWorkflowTaskScheduledEvent.
func (mr *MockMutableStateMockRecorder) ApplyWorkflowTaskScheduledEvent(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowTaskScheduledEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowTaskScheduledEvent), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
}

// ApplyWorkflowTaskStartedEvent mocks base method.
func (m *MockMutableState) ApplyWorkflowTaskStartedEvent(arg0 *WorkflowTaskInfo, arg1, arg2, arg3 int64, arg4 string, arg5 time.Time, arg6 bool, arg7 int64, arg8 *common.WorkerVersionStamp, arg9 int64) (*WorkflowTaskInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyWorkflowTaskStartedEvent", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
	ret0, _ := ret[0].(*WorkflowTaskInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApplyWorkflowTaskStartedEvent indicates an expected call of ApplyWorkflowTaskStartedEvent.
func (mr *MockMutableStateMockRecorder) ApplyWorkflowTaskStartedEvent(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowTaskStartedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowTaskStartedEvent), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
}

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

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

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

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

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

// CheckSpeculativeWorkflowTaskTimeoutTask indicates an expected call of CheckSpeculativeWorkflowTaskTimeoutTask.
func (mr *MockMutableStateMockRecorder) CheckSpeculativeWorkflowTaskTimeoutTask(task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckSpeculativeWorkflowTaskTimeoutTask", reflect.TypeOf((*MockMutableState)(nil).CheckSpeculativeWorkflowTaskTimeoutTask), task)
}

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

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

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

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

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

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

// CloseTransactionAsMutation mocks base method.
func (m *MockMutableState) CloseTransactionAsMutation(transactionPolicy TransactionPolicy) (*persistence0.WorkflowMutation, []*persistence0.WorkflowEvents, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseTransactionAsMutation", transactionPolicy)
	ret0, _ := ret[0].(*persistence0.WorkflowMutation)
	ret1, _ := ret[1].([]*persistence0.WorkflowEvents)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CloseTransactionAsMutation indicates an expected call of CloseTransactionAsMutation.
func (mr *MockMutableStateMockRecorder) CloseTransactionAsMutation(transactionPolicy any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseTransactionAsMutation", reflect.TypeOf((*MockMutableState)(nil).CloseTransactionAsMutation), transactionPolicy)
}

// CloseTransactionAsSnapshot mocks base method.
func (m *MockMutableState) CloseTransactionAsSnapshot(transactionPolicy TransactionPolicy) (*persistence0.WorkflowSnapshot, []*persistence0.WorkflowEvents, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseTransactionAsSnapshot", transactionPolicy)
	ret0, _ := ret[0].(*persistence0.WorkflowSnapshot)
	ret1, _ := ret[1].([]*persistence0.WorkflowEvents)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CloseTransactionAsSnapshot indicates an expected call of CloseTransactionAsSnapshot.
func (mr *MockMutableStateMockRecorder) CloseTransactionAsSnapshot(transactionPolicy any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseTransactionAsSnapshot", reflect.TypeOf((*MockMutableState)(nil).CloseTransactionAsSnapshot), transactionPolicy)
}

// ContinueAsNewMinBackoff mocks base method.
func (m *MockMutableState) ContinueAsNewMinBackoff(backoffDuration *durationpb.Duration) *durationpb.Duration {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContinueAsNewMinBackoff", backoffDuration)
	ret0, _ := ret[0].(*durationpb.Duration)
	return ret0
}

// ContinueAsNewMinBackoff indicates an expected call of ContinueAsNewMinBackoff.
func (mr *MockMutableStateMockRecorder) ContinueAsNewMinBackoff(backoffDuration any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContinueAsNewMinBackoff", reflect.TypeOf((*MockMutableState)(nil).ContinueAsNewMinBackoff), backoffDuration)
}

// CurrentTaskQueue mocks base method.
func (m *MockMutableState) CurrentTaskQueue() *taskqueue.TaskQueue {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CurrentTaskQueue")
	ret0, _ := ret[0].(*taskqueue.TaskQueue)
	return ret0
}

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

// DeleteSignalRequested mocks base method.
func (m *MockMutableState) DeleteSignalRequested(requestID string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DeleteSignalRequested", requestID)
}

// DeleteSignalRequested indicates an expected call of DeleteSignalRequested.
func (mr *MockMutableStateMockRecorder) DeleteSignalRequested(requestID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSignalRequested", reflect.TypeOf((*MockMutableState)(nil).DeleteSignalRequested), requestID)
}

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

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

// GenerateMigrationTasks mocks base method.
func (m *MockMutableState) GenerateMigrationTasks() ([]tasks.Task, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateMigrationTasks")
	ret0, _ := ret[0].([]tasks.Task)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetActivityByActivityID mocks base method.
func (m *MockMutableState) GetActivityByActivityID(arg0 string) (*persistence.ActivityInfo, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActivityByActivityID", arg0)
	ret0, _ := ret[0].(*persistence.ActivityInfo)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

// GetActivityInfo mocks base method.
func (m *MockMutableState) GetActivityInfo(arg0 int64) (*persistence.ActivityInfo, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActivityInfo", arg0)
	ret0, _ := ret[0].(*persistence.ActivityInfo)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

// GetActivityInfoWithTimerHeartbeat mocks base method.
func (m *MockMutableState) GetActivityInfoWithTimerHeartbeat(scheduledEventID int64) (*persistence.ActivityInfo, time.Time, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActivityInfoWithTimerHeartbeat", scheduledEventID)
	ret0, _ := ret[0].(*persistence.ActivityInfo)
	ret1, _ := ret[1].(time.Time)
	ret2, _ := ret[2].(bool)
	return ret0, ret1, ret2
}

// GetActivityInfoWithTimerHeartbeat indicates an expected call of GetActivityInfoWithTimerHeartbeat.
func (mr *MockMutableStateMockRecorder) GetActivityInfoWithTimerHeartbeat(scheduledEventID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActivityInfoWithTimerHeartbeat", reflect.TypeOf((*MockMutableState)(nil).GetActivityInfoWithTimerHeartbeat), scheduledEventID)
}

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

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

// GetActivityType mocks base method.
func (m *MockMutableState) GetActivityType(arg0 context.Context, arg1 *persistence.ActivityInfo) (*common.ActivityType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActivityType", arg0, arg1)
	ret0, _ := ret[0].(*common.ActivityType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// GetBaseWorkflowInfo mocks base method.
func (m *MockMutableState) GetBaseWorkflowInfo() *workflow0.BaseExecutionInfo {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBaseWorkflowInfo")
	ret0, _ := ret[0].(*workflow0.BaseExecutionInfo)
	return ret0
}

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

// GetChildExecutionInfo mocks base method.
func (m *MockMutableState) GetChildExecutionInfo(arg0 int64) (*persistence.ChildExecutionInfo, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChildExecutionInfo", arg0)
	ret0, _ := ret[0].(*persistence.ChildExecutionInfo)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetDeploymentTransition mocks base method.
func (m *MockMutableState) GetDeploymentTransition() *workflow.DeploymentTransition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentTransition")
	ret0, _ := ret[0].(*workflow.DeploymentTransition)
	return ret0
}

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

// GetEffectiveDeployment mocks base method.
func (m *MockMutableState) GetEffectiveDeployment() *deployment.Deployment {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEffectiveDeployment")
	ret0, _ := ret[0].(*deployment.Deployment)
	return ret0
}

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

// GetEffectiveVersioningBehavior mocks base method.
func (m *MockMutableState) GetEffectiveVersioningBehavior() enums.VersioningBehavior {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEffectiveVersioningBehavior")
	ret0, _ := ret[0].(enums.VersioningBehavior)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetMostRecentWorkerVersionStamp mocks base method.
func (m *MockMutableState) GetMostRecentWorkerVersionStamp() *common.WorkerVersionStamp {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMostRecentWorkerVersionStamp")
	ret0, _ := ret[0].(*common.WorkerVersionStamp)
	return ret0
}

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

// GetNamespaceEntry mocks base method.
func (m *MockMutableState) GetNamespaceEntry() *namespace.Namespace {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespaceEntry")
	ret0, _ := ret[0].(*namespace.Namespace)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetRequestCancelInfo mocks base method.
func (m *MockMutableState) GetRequestCancelInfo(arg0 int64) (*persistence.RequestCancelInfo, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRequestCancelInfo", arg0)
	ret0, _ := ret[0].(*persistence.RequestCancelInfo)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

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

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

// GetRetryBackoffDuration mocks base method.
func (m *MockMutableState) GetRetryBackoffDuration(failure *failure.Failure) (time.Duration, enums.RetryState) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRetryBackoffDuration", failure)
	ret0, _ := ret[0].(time.Duration)
	ret1, _ := ret[1].(enums.RetryState)
	return ret0, ret1
}

// GetRetryBackoffDuration indicates an expected call of GetRetryBackoffDuration.
func (mr *MockMutableStateMockRecorder) GetRetryBackoffDuration(failure any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetryBackoffDuration", reflect.TypeOf((*MockMutableState)(nil).GetRetryBackoffDuration), failure)
}

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

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

// GetSignalInfo mocks base method.
func (m *MockMutableState) GetSignalInfo(arg0 int64) (*persistence.SignalInfo, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSignalInfo", arg0)
	ret0, _ := ret[0].(*persistence.SignalInfo)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

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

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

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

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

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

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

// GetTransientWorkflowTaskInfo mocks base method.
func (m *MockMutableState) GetTransientWorkflowTaskInfo(workflowTask *WorkflowTaskInfo, identity string) *history0.TransientWorkflowTaskInfo {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransientWorkflowTaskInfo", workflowTask, identity)
	ret0, _ := ret[0].(*history0.TransientWorkflowTaskInfo)
	return ret0
}

// GetTransientWorkflowTaskInfo indicates an expected call of GetTransientWorkflowTaskInfo.
func (mr *MockMutableStateMockRecorder) GetTransientWorkflowTaskInfo(workflowTask, identity any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransientWorkflowTaskInfo", reflect.TypeOf((*MockMutableState)(nil).GetTransientWorkflowTaskInfo), workflowTask, identity)
}

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

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

// GetUpdateOutcome mocks base method.
func (m *MockMutableState) GetUpdateOutcome(ctx context.Context, updateID string) (*update.Outcome, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUpdateOutcome", ctx, updateID)
	ret0, _ := ret[0].(*update.Outcome)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUpdateOutcome indicates an expected call of GetUpdateOutcome.
func (mr *MockMutableStateMockRecorder) GetUpdateOutcome(ctx, updateID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUpdateOutcome", reflect.TypeOf((*MockMutableState)(nil).GetUpdateOutcome), ctx, updateID)
}

// GetUserTimerInfo mocks base method.
func (m *MockMutableState) GetUserTimerInfo(arg0 string) (*persistence.TimerInfo, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserTimerInfo", arg0)
	ret0, _ := ret[0].(*persistence.TimerInfo)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

// GetUserTimerInfoByEventID mocks base method.
func (m *MockMutableState) GetUserTimerInfoByEventID(arg0 int64) (*persistence.TimerInfo, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserTimerInfoByEventID", arg0)
	ret0, _ := ret[0].(*persistence.TimerInfo)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

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

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

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

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

// GetWorkflowKey mocks base method.
func (m *MockMutableState) GetWorkflowKey() definition.WorkflowKey {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflowKey")
	ret0, _ := ret[0].(definition.WorkflowKey)
	return ret0
}

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

// GetWorkflowStateStatus mocks base method.
func (m *MockMutableState) GetWorkflowStateStatus() (enums0.WorkflowExecutionState, enums.WorkflowExecutionStatus) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflowStateStatus")
	ret0, _ := ret[0].(enums0.WorkflowExecutionState)
	ret1, _ := ret[1].(enums.WorkflowExecutionStatus)
	return ret0, ret1
}

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

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

// GetWorkflowTaskByID indicates an expected call of GetWorkflowTaskByID.
func (mr *MockMutableStateMockRecorder) GetWorkflowTaskByID(scheduledEventID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowTaskByID", reflect.TypeOf((*MockMutableState)(nil).GetWorkflowTaskByID), scheduledEventID)
}

// GetWorkflowType mocks base method.
func (m *MockMutableState) GetWorkflowType() *common.WorkflowType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflowType")
	ret0, _ := ret[0].(*common.WorkflowType)
	return ret0
}

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

// HSM mocks base method.
func (m *MockMutableState) HSM() *hsm.Node {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HSM")
	ret0, _ := ret[0].(*hsm.Node)
	return ret0
}

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

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

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

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

// HasAnyBufferedEvent indicates an expected call of HasAnyBufferedEvent.
func (mr *MockMutableStateMockRecorder) HasAnyBufferedEvent(filter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasAnyBufferedEvent", reflect.TypeOf((*MockMutableState)(nil).HasAnyBufferedEvent), filter)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// IsResourceDuplicated indicates an expected call of IsResourceDuplicated.
func (mr *MockMutableStateMockRecorder) IsResourceDuplicated(resourceDedupKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsResourceDuplicated", reflect.TypeOf((*MockMutableState)(nil).IsResourceDuplicated), resourceDedupKey)
}

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

// IsSignalRequested indicates an expected call of IsSignalRequested.
func (mr *MockMutableStateMockRecorder) IsSignalRequested(requestID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSignalRequested", reflect.TypeOf((*MockMutableState)(nil).IsSignalRequested), requestID)
}

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

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

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

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

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

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

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

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

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

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

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

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

// LoadHistoryEvent mocks base method.
func (m *MockMutableState) LoadHistoryEvent(ctx context.Context, token []byte) (*history.HistoryEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadHistoryEvent", ctx, token)
	ret0, _ := ret[0].(*history.HistoryEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadHistoryEvent indicates an expected call of LoadHistoryEvent.
func (mr *MockMutableStateMockRecorder) LoadHistoryEvent(ctx, token any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadHistoryEvent", reflect.TypeOf((*MockMutableState)(nil).LoadHistoryEvent), ctx, token)
}

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

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

// PopTasks mocks base method.
func (m *MockMutableState) PopTasks() map[tasks.Category][]tasks.Task {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PopTasks")
	ret0, _ := ret[0].(map[tasks.Category][]tasks.Task)
	return ret0
}

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

// RecordLastActivityCompleteTime mocks base method.
func (m *MockMutableState) RecordLastActivityCompleteTime(ai *persistence.ActivityInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecordLastActivityCompleteTime", ai)
}

// RecordLastActivityCompleteTime indicates an expected call of RecordLastActivityCompleteTime.
func (mr *MockMutableStateMockRecorder) RecordLastActivityCompleteTime(ai any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordLastActivityCompleteTime", reflect.TypeOf((*MockMutableState)(nil).RecordLastActivityCompleteTime), ai)
}

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

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

// RegenerateActivityRetryTask mocks base method.
func (m *MockMutableState) RegenerateActivityRetryTask(ai *persistence.ActivityInfo, newScheduledTime time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegenerateActivityRetryTask", ai, newScheduledTime)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegenerateActivityRetryTask indicates an expected call of RegenerateActivityRetryTask.
func (mr *MockMutableStateMockRecorder) RegenerateActivityRetryTask(ai, newScheduledTime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegenerateActivityRetryTask", reflect.TypeOf((*MockMutableState)(nil).RegenerateActivityRetryTask), ai, newScheduledTime)
}

// RejectWorkflowExecutionUpdate mocks base method.
func (m *MockMutableState) RejectWorkflowExecutionUpdate(protocolInstanceID string, updRejection *update.Rejection) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectWorkflowExecutionUpdate", protocolInstanceID, updRejection)
	ret0, _ := ret[0].(error)
	return ret0
}

// RejectWorkflowExecutionUpdate indicates an expected call of RejectWorkflowExecutionUpdate.
func (mr *MockMutableStateMockRecorder) RejectWorkflowExecutionUpdate(protocolInstanceID, updRejection any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectWorkflowExecutionUpdate", reflect.TypeOf((*MockMutableState)(nil).RejectWorkflowExecutionUpdate), protocolInstanceID, updRejection)
}

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

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

// RetryActivity mocks base method.
func (m *MockMutableState) RetryActivity(ai *persistence.ActivityInfo, failure *failure.Failure) (enums.RetryState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RetryActivity", ai, failure)
	ret0, _ := ret[0].(enums.RetryState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RetryActivity indicates an expected call of RetryActivity.
func (mr *MockMutableStateMockRecorder) RetryActivity(ai, failure any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetryActivity", reflect.TypeOf((*MockMutableState)(nil).RetryActivity), ai, failure)
}

// SetBaseWorkflow mocks base method.
func (m *MockMutableState) SetBaseWorkflow(baseRunID string, baseRunLowestCommonAncestorEventID, baseRunLowestCommonAncestorEventVersion int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBaseWorkflow", baseRunID, baseRunLowestCommonAncestorEventID, baseRunLowestCommonAncestorEventVersion)
}

// SetBaseWorkflow indicates an expected call of SetBaseWorkflow.
func (mr *MockMutableStateMockRecorder) SetBaseWorkflow(baseRunID, baseRunLowestCommonAncestorEventID, baseRunLowestCommonAncestorEventVersion any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBaseWorkflow", reflect.TypeOf((*MockMutableState)(nil).SetBaseWorkflow), baseRunID, baseRunLowestCommonAncestorEventID, baseRunLowestCommonAncestorEventVersion)
}

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

// SetCurrentBranchToken indicates an expected call of SetCurrentBranchToken.
func (mr *MockMutableStateMockRecorder) SetCurrentBranchToken(branchToken any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentBranchToken", reflect.TypeOf((*MockMutableState)(nil).SetCurrentBranchToken), branchToken)
}

// SetHistoryBuilder mocks base method.
func (m *MockMutableState) SetHistoryBuilder(hBuilder *historybuilder.HistoryBuilder) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetHistoryBuilder", hBuilder)
}

// SetHistoryBuilder indicates an expected call of SetHistoryBuilder.
func (mr *MockMutableStateMockRecorder) SetHistoryBuilder(hBuilder any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHistoryBuilder", reflect.TypeOf((*MockMutableState)(nil).SetHistoryBuilder), hBuilder)
}

// SetHistoryTree mocks base method.
func (m *MockMutableState) SetHistoryTree(executionTimeout, runTimeout *durationpb.Duration, treeID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHistoryTree", executionTimeout, runTimeout, treeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHistoryTree indicates an expected call of SetHistoryTree.
func (mr *MockMutableStateMockRecorder) SetHistoryTree(executionTimeout, runTimeout, treeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHistoryTree", reflect.TypeOf((*MockMutableState)(nil).SetHistoryTree), executionTimeout, runTimeout, treeID)
}

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

// SetSpeculativeWorkflowTaskTimeoutTask indicates an expected call of SetSpeculativeWorkflowTaskTimeoutTask.
func (mr *MockMutableStateMockRecorder) SetSpeculativeWorkflowTaskTimeoutTask(task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSpeculativeWorkflowTaskTimeoutTask", reflect.TypeOf((*MockMutableState)(nil).SetSpeculativeWorkflowTaskTimeoutTask), task)
}

// SetStickyTaskQueue mocks base method.
func (m *MockMutableState) SetStickyTaskQueue(name string, scheduleToStartTimeout *durationpb.Duration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStickyTaskQueue", name, scheduleToStartTimeout)
}

// SetStickyTaskQueue indicates an expected call of SetStickyTaskQueue.
func (mr *MockMutableStateMockRecorder) SetStickyTaskQueue(name, scheduleToStartTimeout any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStickyTaskQueue", reflect.TypeOf((*MockMutableState)(nil).SetStickyTaskQueue), name, scheduleToStartTimeout)
}

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

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

// ShouldResetActivityTimerTaskMask mocks base method.
func (m *MockMutableState) ShouldResetActivityTimerTaskMask(current, incoming *persistence.ActivityInfo) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ShouldResetActivityTimerTaskMask", current, incoming)
	ret0, _ := ret[0].(bool)
	return ret0
}

// ShouldResetActivityTimerTaskMask indicates an expected call of ShouldResetActivityTimerTaskMask.
func (mr *MockMutableStateMockRecorder) ShouldResetActivityTimerTaskMask(current, incoming any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldResetActivityTimerTaskMask", reflect.TypeOf((*MockMutableState)(nil).ShouldResetActivityTimerTaskMask), current, incoming)
}

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

// StartDeploymentTransition indicates an expected call of StartDeploymentTransition.
func (mr *MockMutableStateMockRecorder) StartDeploymentTransition(deployment any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartDeploymentTransition", reflect.TypeOf((*MockMutableState)(nil).StartDeploymentTransition), deployment)
}

// StartTransaction mocks base method.
func (m *MockMutableState) StartTransaction(entry *namespace.Namespace) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartTransaction", entry)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartTransaction indicates an expected call of StartTransaction.
func (mr *MockMutableStateMockRecorder) StartTransaction(entry any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTransaction", reflect.TypeOf((*MockMutableState)(nil).StartTransaction), entry)
}

// TaskQueueScheduleToStartTimeout mocks base method.
func (m *MockMutableState) TaskQueueScheduleToStartTimeout(name string) (*taskqueue.TaskQueue, *durationpb.Duration) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TaskQueueScheduleToStartTimeout", name)
	ret0, _ := ret[0].(*taskqueue.TaskQueue)
	ret1, _ := ret[1].(*durationpb.Duration)
	return ret0, ret1
}

// TaskQueueScheduleToStartTimeout indicates an expected call of TaskQueueScheduleToStartTimeout.
func (mr *MockMutableStateMockRecorder) TaskQueueScheduleToStartTimeout(name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskQueueScheduleToStartTimeout", reflect.TypeOf((*MockMutableState)(nil).TaskQueueScheduleToStartTimeout), name)
}

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

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

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

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

// UpdateActivityProgress mocks base method.
func (m *MockMutableState) UpdateActivityProgress(ai *persistence.ActivityInfo, request *workflowservice.RecordActivityTaskHeartbeatRequest) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateActivityProgress", ai, request)
}

// UpdateActivityProgress indicates an expected call of UpdateActivityProgress.
func (mr *MockMutableStateMockRecorder) UpdateActivityProgress(ai, request any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateActivityProgress", reflect.TypeOf((*MockMutableState)(nil).UpdateActivityProgress), ai, request)
}

// UpdateActivityTaskStatusWithTimerHeartbeat mocks base method.
func (m *MockMutableState) UpdateActivityTaskStatusWithTimerHeartbeat(scheduleEventId int64, timerTaskStatus int32, heartbeatTimeoutVisibility *time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateActivityTaskStatusWithTimerHeartbeat", scheduleEventId, timerTaskStatus, heartbeatTimeoutVisibility)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateActivityTaskStatusWithTimerHeartbeat indicates an expected call of UpdateActivityTaskStatusWithTimerHeartbeat.
func (mr *MockMutableStateMockRecorder) UpdateActivityTaskStatusWithTimerHeartbeat(scheduleEventId, timerTaskStatus, heartbeatTimeoutVisibility any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateActivityTaskStatusWithTimerHeartbeat", reflect.TypeOf((*MockMutableState)(nil).UpdateActivityTaskStatusWithTimerHeartbeat), scheduleEventId, timerTaskStatus, heartbeatTimeoutVisibility)
}

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

// UpdateBuildIdAssignment indicates an expected call of UpdateBuildIdAssignment.
func (mr *MockMutableStateMockRecorder) UpdateBuildIdAssignment(buildId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBuildIdAssignment", reflect.TypeOf((*MockMutableState)(nil).UpdateBuildIdAssignment), buildId)
}

// UpdateCurrentVersion mocks base method.
func (m *MockMutableState) UpdateCurrentVersion(version int64, forceUpdate bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCurrentVersion", version, forceUpdate)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCurrentVersion indicates an expected call of UpdateCurrentVersion.
func (mr *MockMutableStateMockRecorder) UpdateCurrentVersion(version, forceUpdate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCurrentVersion", reflect.TypeOf((*MockMutableState)(nil).UpdateCurrentVersion), version, forceUpdate)
}

// UpdateDuplicatedResource mocks base method.
func (m *MockMutableState) UpdateDuplicatedResource(resourceDedupKey definition.DeduplicationID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateDuplicatedResource", resourceDedupKey)
}

// UpdateDuplicatedResource indicates an expected call of UpdateDuplicatedResource.
func (mr *MockMutableStateMockRecorder) UpdateDuplicatedResource(resourceDedupKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDuplicatedResource", reflect.TypeOf((*MockMutableState)(nil).UpdateDuplicatedResource), resourceDedupKey)
}

// UpdateResetRunID mocks base method.
func (m *MockMutableState) UpdateResetRunID(runID string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateResetRunID", runID)
}

// UpdateResetRunID indicates an expected call of UpdateResetRunID.
func (mr *MockMutableStateMockRecorder) UpdateResetRunID(runID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResetRunID", reflect.TypeOf((*MockMutableState)(nil).UpdateResetRunID), runID)
}

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

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

// UpdateUserTimerTaskStatus mocks base method.
func (m *MockMutableState) UpdateUserTimerTaskStatus(timerId string, status int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserTimerTaskStatus", timerId, status)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateUserTimerTaskStatus indicates an expected call of UpdateUserTimerTaskStatus.
func (mr *MockMutableStateMockRecorder) UpdateUserTimerTaskStatus(timerId, status any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserTimerTaskStatus", reflect.TypeOf((*MockMutableState)(nil).UpdateUserTimerTaskStatus), timerId, status)
}

// UpdateWorkflowStateStatus mocks base method.
func (m *MockMutableState) UpdateWorkflowStateStatus(state enums0.WorkflowExecutionState, status enums.WorkflowExecutionStatus) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkflowStateStatus", state, status)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkflowStateStatus indicates an expected call of UpdateWorkflowStateStatus.
func (mr *MockMutableStateMockRecorder) UpdateWorkflowStateStatus(state, status any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkflowStateStatus", reflect.TypeOf((*MockMutableState)(nil).UpdateWorkflowStateStatus), state, status)
}

// VisitUpdates mocks base method.
func (m *MockMutableState) VisitUpdates(visitor func(string, *persistence.UpdateInfo)) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "VisitUpdates", visitor)
}

// VisitUpdates indicates an expected call of VisitUpdates.
func (mr *MockMutableStateMockRecorder) VisitUpdates(visitor any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VisitUpdates", reflect.TypeOf((*MockMutableState)(nil).VisitUpdates), visitor)
}