diff --git a/service/history/history_engine_test.go b/service/history/history_engine_test.go
index c8d01fc8942..3e80a740a00 100644
--- a/service/history/history_engine_test.go
+++ b/service/history/history_engine_test.go
@@ -1759,13 +1759,11 @@ func (s *engineSuite) testRespondWorkflowTaskCompletedSignalGeneration() *histor
 	_, err := s.historyEngine.SignalWorkflowExecution(context.Background(), signalRequest)
 	s.NoError(err)
 
-	if !skipGenerateTask {
-		s.mockSearchAttributesProvider.EXPECT().GetSearchAttributes(gomock.Any(), false).Return(searchattribute.TestNameTypeMap, nil)
-		s.mockSearchAttributesMapperProvider.EXPECT().GetMapper(tests.Namespace).Return(&searchattribute.TestMapper{Namespace: tests.Namespace.String()}, nil).AnyTimes()
-		s.mockNamespaceCache.EXPECT().GetNamespaceName(tests.NamespaceID).Return(tests.Namespace, nil)
-		s.mockVisibilityMgr.EXPECT().GetIndexName().Return(esIndexName).AnyTimes()
-		s.mockExecutionMgr.EXPECT().ReadHistoryBranch(gomock.Any(), gomock.Any()).Return(&persistence.ReadHistoryBranchResponse{HistoryEvents: []*historypb.HistoryEvent{}}, nil)
-	}
+	s.mockSearchAttributesProvider.EXPECT().GetSearchAttributes(gomock.Any(), false).Return(searchattribute.TestNameTypeMap, nil)
+	s.mockSearchAttributesMapperProvider.EXPECT().GetMapper(tests.Namespace).Return(&searchattribute.TestMapper{Namespace: tests.Namespace.String()}, nil).AnyTimes()
+	s.mockNamespaceCache.EXPECT().GetNamespaceName(tests.NamespaceID).Return(tests.Namespace, nil)
+	s.mockVisibilityMgr.EXPECT().GetIndexName().Return(esIndexName).AnyTimes()
+	s.mockExecutionMgr.EXPECT().ReadHistoryBranch(gomock.Any(), gomock.Any()).Return(&persistence.ReadHistoryBranchResponse{HistoryEvents: []*historypb.HistoryEvent{}}, nil)
 
 	var commands []*commandpb.Command
 	resp, err := s.historyEngine.RespondWorkflowTaskCompleted(context.Background(), &historyservice.RespondWorkflowTaskCompletedRequest{
diff --git a/service/history/historybuilder/history_builder_categorization_test.go b/service/history/historybuilder/history_builder_categorization_test.go
index 2d5eb220b94..6a8a575031c 100644
--- a/service/history/historybuilder/history_builder_categorization_test.go
+++ b/service/history/historybuilder/history_builder_categorization_test.go
@@ -1459,7 +1459,6 @@ func (s *sutTestingAdapter) AddWorkflowExecutionSignaledEvent(_ ...eventConfig)
 		nil,
 		"identity-1",
 		nil,
-		false,
 		nil,
 		nil,
 	)
diff --git a/service/history/historybuilder/history_builder_test.go b/service/history/historybuilder/history_builder_test.go
index 0c009f63fcb..0e484edc0f8 100644
--- a/service/history/historybuilder/history_builder_test.go
+++ b/service/history/historybuilder/history_builder_test.go
@@ -353,7 +353,7 @@ func (s *historyBuilderSuite) TestWorkflowExecutionCancelRequested() {
 func (s *historyBuilderSuite) TestWorkflowExecutionSignaled() {
 	signalName := "random signal name"
 	event := s.historyBuilder.AddWorkflowExecutionSignaledEvent(
-		signalName, testPayloads, testIdentity, testHeader, false, nil, nil,
+		signalName, testPayloads, testIdentity, testHeader, nil, nil,
 	)
 	s.Equal(event, s.flush())
 	s.Equal(&historypb.HistoryEvent{
@@ -2370,7 +2370,6 @@ func (s *historyBuilderSuite) TestBufferSize_Memory() {
 		&commonpb.Payloads{},
 		"identity",
 		&commonpb.Header{},
-		false,
 		nil,
 		nil,
 	)
diff --git a/service/history/ndc/workflow_resetter_test.go b/service/history/ndc/workflow_resetter_test.go
index fc716c060d9..f6a7883ceb0 100644
--- a/service/history/ndc/workflow_resetter_test.go
+++ b/service/history/ndc/workflow_resetter_test.go
@@ -970,7 +970,7 @@ func (s *workflowResetterSuite) TestReapplyEvents_Excludes() {
 	ms := workflow.NewMockMutableState(s.controller)
 	// Assert that none of these following methods are invoked.
 	arg := gomock.Any()
-	ms.EXPECT().AddWorkflowExecutionSignaled(arg, arg, arg, arg, arg, arg).Times(0)
+	ms.EXPECT().AddWorkflowExecutionSignaled(arg, arg, arg, arg, arg).Times(0)
 	ms.EXPECT().AddWorkflowExecutionUpdateAdmittedEvent(arg, arg).Times(0)
 	ms.EXPECT().AddHistoryEvent(arg, arg).Times(0)
 
diff --git a/service/history/workflow/mutable_state_impl_test.go b/service/history/workflow/mutable_state_impl_test.go
index 4b6839836d4..3376d976a8d 100644
--- a/service/history/workflow/mutable_state_impl_test.go
+++ b/service/history/workflow/mutable_state_impl_test.go
@@ -1442,7 +1442,6 @@ func (s *mutableStateSuite) TestTotalEntitiesCount() {
 		&commonpb.Payloads{},
 		"identity",
 		&commonpb.Header{},
-		false,
 		nil,
 	)
 	s.NoError(err)
@@ -1915,7 +1914,6 @@ func (s *mutableStateSuite) TestCloseTransactionUpdateTransition() {
 					&commonpb.Payloads{},
 					"identity",
 					&commonpb.Header{},
-					false,
 					nil,
 					nil,
 				)
diff --git a/service/history/workflow/mutable_state_mock.go b/service/history/workflow/mutable_state_mock.go
index 5bc440ff7f2..65d10403615 100644
--- a/service/history/workflow/mutable_state_mock.go
+++ b/service/history/workflow/mutable_state_mock.go
@@ -24,6 +24,11 @@
 
 // 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
@@ -33,30 +38,30 @@ import (
 	reflect "reflect"
 	time "time"
 
-	gomock "github.com/golang/mock/gomock"
 	nexus "github.com/nexus-rpc/sdk-go/nexus"
-	v1 "go.temporal.io/api/command/v1"
-	v10 "go.temporal.io/api/common/v1"
-	v11 "go.temporal.io/api/enums/v1"
-	v12 "go.temporal.io/api/failure/v1"
-	v13 "go.temporal.io/api/history/v1"
-	v14 "go.temporal.io/api/taskqueue/v1"
-	v15 "go.temporal.io/api/update/v1"
-	v16 "go.temporal.io/api/workflow/v1"
-	v17 "go.temporal.io/api/workflowservice/v1"
-	v18 "go.temporal.io/server/api/clock/v1"
-	v19 "go.temporal.io/server/api/enums/v1"
-	v110 "go.temporal.io/server/api/history/v1"
-	v111 "go.temporal.io/server/api/historyservice/v1"
-	v112 "go.temporal.io/server/api/persistence/v1"
-	v113 "go.temporal.io/server/api/taskqueue/v1"
-	v114 "go.temporal.io/server/api/workflow/v1"
+	command "go.temporal.io/api/command/v1"
+	common "go.temporal.io/api/common/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"
-	persistence "go.temporal.io/server/common/persistence"
+	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"
 )
@@ -85,280 +90,280 @@ func (m *MockMutableState) EXPECT() *MockMutableStateMockRecorder {
 }
 
 // AddActivityTaskCancelRequestedEvent mocks base method.
-func (m *MockMutableState) AddActivityTaskCancelRequestedEvent(arg0, arg1 int64, arg2 string) (*v13.HistoryEvent, *v112.ActivityInfo, error) {
+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].(*v13.HistoryEvent)
-	ret1, _ := ret[1].(*v112.ActivityInfo)
+	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 interface{}) *gomock.Call {
+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 *v10.Payloads, arg4 string) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v17.RespondActivityTaskCompletedRequest) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v12.Failure, arg3 v11.RetryState, arg4 string, arg5 *v10.WorkerVersionStamp) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v1.ScheduleActivityTaskCommandAttributes, arg2 bool) (*v13.HistoryEvent, *v112.ActivityInfo, error) {
+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].(*v13.HistoryEvent)
-	ret1, _ := ret[1].(*v112.ActivityInfo)
+	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 interface{}) *gomock.Call {
+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 *v112.ActivityInfo, arg1 int64, arg2, arg3 string, arg4 *v10.WorkerVersionStamp, arg5 *v113.BuildIdRedirectInfo) (*v13.HistoryEvent, error) {
+func (m *MockMutableState) AddActivityTaskStartedEvent(arg0 *persistence.ActivityInfo, arg1 int64, arg2, arg3 string, arg4 *common.WorkerVersionStamp, arg5 *taskqueue0.BuildIdRedirectInfo) (*history.HistoryEvent, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AddActivityTaskStartedEvent", arg0, arg1, arg2, arg3, arg4, arg5)
-	ret0, _ := ret[0].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+func (mr *MockMutableStateMockRecorder) AddActivityTaskStartedEvent(arg0, arg1, arg2, arg3, arg4, arg5 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)
 }
 
 // AddActivityTaskTimedOutEvent mocks base method.
-func (m *MockMutableState) AddActivityTaskTimedOutEvent(arg0, arg1 int64, arg2 *v12.Failure, arg3 v11.RetryState) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v10.WorkflowExecution, arg2 *v13.WorkflowExecutionCanceledEventAttributes) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v10.WorkflowExecution, arg2 *v13.WorkflowExecutionCompletedEventAttributes) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v10.WorkflowExecution, arg2 *v13.WorkflowExecutionFailedEventAttributes) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v10.WorkflowExecution, arg1 *v10.WorkflowType, arg2 int64, arg3 *v10.Header, arg4 *v18.VectorClock) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v10.WorkflowExecution, arg2 *v13.WorkflowExecutionTerminatedEventAttributes) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v10.WorkflowExecution, arg2 *v13.WorkflowExecutionTimedOutEventAttributes) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v1.CompleteWorkflowExecutionCommandAttributes, arg2 string) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v1.ContinueAsNewWorkflowExecutionCommandAttributes) (*v13.HistoryEvent, MutableState, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 v11.RetryState, arg2 *v1.FailWorkflowExecutionCommandAttributes, arg3 string) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v18.VectorClock, event *v13.HistoryEvent, bypassTaskGeneration bool) (int64, error) {
+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)
@@ -367,21 +372,21 @@ func (m *MockMutableState) AddFirstWorkflowTaskScheduled(parentClock *v18.Vector
 }
 
 // AddFirstWorkflowTaskScheduled indicates an expected call of AddFirstWorkflowTaskScheduled.
-func (mr *MockMutableStateMockRecorder) AddFirstWorkflowTaskScheduled(parentClock, event, bypassTaskGeneration interface{}) *gomock.Call {
+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 v11.EventType, setAttributes func(*v13.HistoryEvent)) *v13.HistoryEvent {
+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].(*v13.HistoryEvent)
+	ret0, _ := ret[0].(*history.HistoryEvent)
 	return ret0
 }
 
 // AddHistoryEvent indicates an expected call of AddHistoryEvent.
-func (mr *MockMutableStateMockRecorder) AddHistoryEvent(t, setAttributes interface{}) *gomock.Call {
+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)
 }
@@ -393,84 +398,84 @@ func (m *MockMutableState) AddHistorySize(size int64) {
 }
 
 // AddHistorySize indicates an expected call of AddHistorySize.
-func (mr *MockMutableStateMockRecorder) AddHistorySize(size interface{}) *gomock.Call {
+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 *v1.RecordMarkerCommandAttributes) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 v11.CancelExternalWorkflowExecutionFailedCause) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v1.RequestCancelExternalWorkflowExecutionCommandAttributes, arg3 namespace.ID) (*v13.HistoryEvent, *v112.RequestCancelInfo, error) {
+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].(*v13.HistoryEvent)
-	ret1, _ := ret[1].(*v112.RequestCancelInfo)
+	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 interface{}) *gomock.Call {
+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 v11.SignalExternalWorkflowExecutionFailedCause) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v1.SignalExternalWorkflowExecutionCommandAttributes, arg3 namespace.ID) (*v13.HistoryEvent, *v112.SignalInfo, error) {
+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].(*v13.HistoryEvent)
-	ret1, _ := ret[1].(*v112.SignalInfo)
+	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 interface{}) *gomock.Call {
+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)
 }
@@ -482,38 +487,38 @@ func (m *MockMutableState) AddSignalRequested(requestID string) {
 }
 
 // AddSignalRequested indicates an expected call of AddSignalRequested.
-func (mr *MockMutableStateMockRecorder) AddSignalRequested(requestID interface{}) *gomock.Call {
+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 v11.StartChildWorkflowExecutionFailedCause, arg2 *v13.StartChildWorkflowExecutionInitiatedEventAttributes) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v1.StartChildWorkflowExecutionCommandAttributes, arg3 namespace.ID) (*v13.HistoryEvent, *v112.ChildExecutionInfo, error) {
+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].(*v13.HistoryEvent)
-	ret1, _ := ret[1].(*v112.ChildExecutionInfo)
+	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 interface{}) *gomock.Call {
+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)
 }
@@ -521,7 +526,7 @@ func (mr *MockMutableStateMockRecorder) AddStartChildWorkflowExecutionInitiatedE
 // AddTasks mocks base method.
 func (m *MockMutableState) AddTasks(tasks ...tasks.Task) {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{}
+	varargs := []any{}
 	for _, a := range tasks {
 		varargs = append(varargs, a)
 	}
@@ -529,299 +534,299 @@ func (m *MockMutableState) AddTasks(tasks ...tasks.Task) {
 }
 
 // AddTasks indicates an expected call of AddTasks.
-func (mr *MockMutableStateMockRecorder) AddTasks(tasks ...interface{}) *gomock.Call {
+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 v11.RetryState, arg2 string) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v1.CancelTimerCommandAttributes, arg2 string) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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) (*v13.HistoryEvent, error) {
+func (m *MockMutableState) AddTimerFiredEvent(arg0 string) (*history.HistoryEvent, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AddTimerFiredEvent", arg0)
-	ret0, _ := ret[0].(*v13.HistoryEvent)
+	ret0, _ := ret[0].(*history.HistoryEvent)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // AddTimerFiredEvent indicates an expected call of AddTimerFiredEvent.
-func (mr *MockMutableStateMockRecorder) AddTimerFiredEvent(arg0 interface{}) *gomock.Call {
+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 *v1.StartTimerCommandAttributes) (*v13.HistoryEvent, *v112.TimerInfo, error) {
+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].(*v13.HistoryEvent)
-	ret1, _ := ret[1].(*v112.TimerInfo)
+	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 interface{}) *gomock.Call {
+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 *v1.UpsertWorkflowSearchAttributesCommandAttributes) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v111.RequestCancelWorkflowExecutionRequest) (*v13.HistoryEvent, error) {
+func (m *MockMutableState) AddWorkflowExecutionCancelRequestedEvent(arg0 *historyservice.RequestCancelWorkflowExecutionRequest) (*history.HistoryEvent, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AddWorkflowExecutionCancelRequestedEvent", arg0)
-	ret0, _ := ret[0].(*v13.HistoryEvent)
+	ret0, _ := ret[0].(*history.HistoryEvent)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // AddWorkflowExecutionCancelRequestedEvent indicates an expected call of AddWorkflowExecutionCancelRequestedEvent.
-func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionCancelRequestedEvent(arg0 interface{}) *gomock.Call {
+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 *v1.CancelWorkflowExecutionCommandAttributes) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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)
 }
 
 // AddWorkflowExecutionSignaled mocks base method.
-func (m *MockMutableState) AddWorkflowExecutionSignaled(signalName string, input *v10.Payloads, identity string, header *v10.Header, links []*v10.Link) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v10.Payloads, identity string, header *v10.Header, externalWorkflowExecution *v10.WorkflowExecution, links []*v10.Link) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v10.WorkflowExecution, arg1 *v111.StartWorkflowExecutionRequest) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v10.WorkflowExecution, arg1 *v111.StartWorkflowExecutionRequest, arg2 *v16.ResetPoints, arg3, arg4 string) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v10.Payloads, identity string, deleteAfterTerminate bool, links []*v10.Link) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v15.Request) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v15.Request, origin v11.UpdateAdmittedEventOrigin) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v15.Response) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v1.ModifyWorkflowPropertiesCommandAttributes) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v17.RespondWorkflowTaskCompletedRequest, arg2 WorkflowTaskCompletionLimits) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 v11.WorkflowTaskFailedCause, failure *v12.Failure, identity string, versioningStamp *v10.WorkerVersionStamp, binChecksum, baseRunID, newRunID string, forkEventVersion int64) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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) (*v13.HistoryEvent, error) {
+func (m *MockMutableState) AddWorkflowTaskScheduleToStartTimeoutEvent(workflowTask *WorkflowTaskInfo) (*history.HistoryEvent, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AddWorkflowTaskScheduleToStartTimeoutEvent", workflowTask)
-	ret0, _ := ret[0].(*v13.HistoryEvent)
+	ret0, _ := ret[0].(*history.HistoryEvent)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // AddWorkflowTaskScheduleToStartTimeoutEvent indicates an expected call of AddWorkflowTaskScheduleToStartTimeoutEvent.
-func (mr *MockMutableStateMockRecorder) AddWorkflowTaskScheduleToStartTimeoutEvent(workflowTask interface{}) *gomock.Call {
+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 v19.WorkflowTaskType) (*WorkflowTaskInfo, error) {
+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)
@@ -830,13 +835,13 @@ func (m *MockMutableState) AddWorkflowTaskScheduledEvent(bypassTaskGeneration bo
 }
 
 // AddWorkflowTaskScheduledEvent indicates an expected call of AddWorkflowTaskScheduledEvent.
-func (mr *MockMutableStateMockRecorder) AddWorkflowTaskScheduledEvent(bypassTaskGeneration, workflowTaskType interface{}) *gomock.Call {
+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 v19.WorkflowTaskType) (*WorkflowTaskInfo, error) {
+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)
@@ -845,44 +850,44 @@ func (m *MockMutableState) AddWorkflowTaskScheduledEventAsHeartbeat(bypassTaskGe
 }
 
 // AddWorkflowTaskScheduledEventAsHeartbeat indicates an expected call of AddWorkflowTaskScheduledEventAsHeartbeat.
-func (mr *MockMutableStateMockRecorder) AddWorkflowTaskScheduledEventAsHeartbeat(bypassTaskGeneration, originalScheduledTimestamp, workflowTaskType interface{}) *gomock.Call {
+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 *v14.TaskQueue, arg3 string, arg4 *v10.WorkerVersionStamp, arg5 *v113.BuildIdRedirectInfo, arg6 bool) (*v13.HistoryEvent, *WorkflowTaskInfo, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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) (*v13.HistoryEvent, error) {
+func (m *MockMutableState) AddWorkflowTaskTimedOutEvent(workflowTask *WorkflowTaskInfo) (*history.HistoryEvent, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AddWorkflowTaskTimedOutEvent", workflowTask)
-	ret0, _ := ret[0].(*v13.HistoryEvent)
+	ret0, _ := ret[0].(*history.HistoryEvent)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // AddWorkflowTaskTimedOutEvent indicates an expected call of AddWorkflowTaskTimedOutEvent.
-func (mr *MockMutableStateMockRecorder) AddWorkflowTaskTimedOutEvent(workflowTask interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyActivityTaskCancelRequestedEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyActivityTaskCancelRequestedEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -890,13 +895,13 @@ func (m *MockMutableState) ApplyActivityTaskCancelRequestedEvent(arg0 *v13.Histo
 }
 
 // ApplyActivityTaskCancelRequestedEvent indicates an expected call of ApplyActivityTaskCancelRequestedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyActivityTaskCancelRequestedEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyActivityTaskCanceledEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyActivityTaskCanceledEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -904,13 +909,13 @@ func (m *MockMutableState) ApplyActivityTaskCanceledEvent(arg0 *v13.HistoryEvent
 }
 
 // ApplyActivityTaskCanceledEvent indicates an expected call of ApplyActivityTaskCanceledEvent.
-func (mr *MockMutableStateMockRecorder) ApplyActivityTaskCanceledEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyActivityTaskCompletedEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyActivityTaskCompletedEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -918,13 +923,13 @@ func (m *MockMutableState) ApplyActivityTaskCompletedEvent(arg0 *v13.HistoryEven
 }
 
 // ApplyActivityTaskCompletedEvent indicates an expected call of ApplyActivityTaskCompletedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyActivityTaskCompletedEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyActivityTaskFailedEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyActivityTaskFailedEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -932,28 +937,28 @@ func (m *MockMutableState) ApplyActivityTaskFailedEvent(arg0 *v13.HistoryEvent)
 }
 
 // ApplyActivityTaskFailedEvent indicates an expected call of ApplyActivityTaskFailedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyActivityTaskFailedEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) (*v112.ActivityInfo, error) {
+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].(*v112.ActivityInfo)
+	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 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyActivityTaskStartedEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyActivityTaskStartedEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -961,13 +966,13 @@ func (m *MockMutableState) ApplyActivityTaskStartedEvent(arg0 *v13.HistoryEvent)
 }
 
 // ApplyActivityTaskStartedEvent indicates an expected call of ApplyActivityTaskStartedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyActivityTaskStartedEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyActivityTaskTimedOutEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyActivityTaskTimedOutEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -975,7 +980,7 @@ func (m *MockMutableState) ApplyActivityTaskTimedOutEvent(arg0 *v13.HistoryEvent
 }
 
 // ApplyActivityTaskTimedOutEvent indicates an expected call of ApplyActivityTaskTimedOutEvent.
-func (mr *MockMutableStateMockRecorder) ApplyActivityTaskTimedOutEvent(arg0 interface{}) *gomock.Call {
+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)
 }
@@ -989,13 +994,13 @@ func (m *MockMutableState) ApplyBuildIdRedirect(startingTaskScheduledEventId int
 }
 
 // ApplyBuildIdRedirect indicates an expected call of ApplyBuildIdRedirect.
-func (mr *MockMutableStateMockRecorder) ApplyBuildIdRedirect(startingTaskScheduledEventId, buildId, redirectCounter interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyChildWorkflowExecutionCanceledEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyChildWorkflowExecutionCanceledEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -1003,13 +1008,13 @@ func (m *MockMutableState) ApplyChildWorkflowExecutionCanceledEvent(arg0 *v13.Hi
 }
 
 // ApplyChildWorkflowExecutionCanceledEvent indicates an expected call of ApplyChildWorkflowExecutionCanceledEvent.
-func (mr *MockMutableStateMockRecorder) ApplyChildWorkflowExecutionCanceledEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyChildWorkflowExecutionCompletedEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyChildWorkflowExecutionCompletedEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -1017,13 +1022,13 @@ func (m *MockMutableState) ApplyChildWorkflowExecutionCompletedEvent(arg0 *v13.H
 }
 
 // ApplyChildWorkflowExecutionCompletedEvent indicates an expected call of ApplyChildWorkflowExecutionCompletedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyChildWorkflowExecutionCompletedEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyChildWorkflowExecutionFailedEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyChildWorkflowExecutionFailedEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -1031,13 +1036,13 @@ func (m *MockMutableState) ApplyChildWorkflowExecutionFailedEvent(arg0 *v13.Hist
 }
 
 // ApplyChildWorkflowExecutionFailedEvent indicates an expected call of ApplyChildWorkflowExecutionFailedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyChildWorkflowExecutionFailedEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent, arg1 *v18.VectorClock) error {
+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)
@@ -1045,13 +1050,13 @@ func (m *MockMutableState) ApplyChildWorkflowExecutionStartedEvent(arg0 *v13.His
 }
 
 // ApplyChildWorkflowExecutionStartedEvent indicates an expected call of ApplyChildWorkflowExecutionStartedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyChildWorkflowExecutionStartedEvent(arg0, arg1 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyChildWorkflowExecutionTerminatedEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyChildWorkflowExecutionTerminatedEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -1059,13 +1064,13 @@ func (m *MockMutableState) ApplyChildWorkflowExecutionTerminatedEvent(arg0 *v13.
 }
 
 // ApplyChildWorkflowExecutionTerminatedEvent indicates an expected call of ApplyChildWorkflowExecutionTerminatedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyChildWorkflowExecutionTerminatedEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyChildWorkflowExecutionTimedOutEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyChildWorkflowExecutionTimedOutEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -1073,13 +1078,13 @@ func (m *MockMutableState) ApplyChildWorkflowExecutionTimedOutEvent(arg0 *v13.Hi
 }
 
 // ApplyChildWorkflowExecutionTimedOutEvent indicates an expected call of ApplyChildWorkflowExecutionTimedOutEvent.
-func (mr *MockMutableStateMockRecorder) ApplyChildWorkflowExecutionTimedOutEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyExternalWorkflowExecutionCancelRequested(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyExternalWorkflowExecutionCancelRequested", arg0)
 	ret0, _ := ret[0].(error)
@@ -1087,13 +1092,13 @@ func (m *MockMutableState) ApplyExternalWorkflowExecutionCancelRequested(arg0 *v
 }
 
 // ApplyExternalWorkflowExecutionCancelRequested indicates an expected call of ApplyExternalWorkflowExecutionCancelRequested.
-func (mr *MockMutableStateMockRecorder) ApplyExternalWorkflowExecutionCancelRequested(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyExternalWorkflowExecutionSignaled(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyExternalWorkflowExecutionSignaled", arg0)
 	ret0, _ := ret[0].(error)
@@ -1101,13 +1106,13 @@ func (m *MockMutableState) ApplyExternalWorkflowExecutionSignaled(arg0 *v13.Hist
 }
 
 // ApplyExternalWorkflowExecutionSignaled indicates an expected call of ApplyExternalWorkflowExecutionSignaled.
-func (mr *MockMutableStateMockRecorder) ApplyExternalWorkflowExecutionSignaled(arg0 interface{}) *gomock.Call {
+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 *v112.WorkflowMutableStateMutation) error {
+func (m *MockMutableState) ApplyMutation(mutation *persistence.WorkflowMutableStateMutation) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyMutation", mutation)
 	ret0, _ := ret[0].(error)
@@ -1115,13 +1120,13 @@ func (m *MockMutableState) ApplyMutation(mutation *v112.WorkflowMutableStateMuta
 }
 
 // ApplyMutation indicates an expected call of ApplyMutation.
-func (mr *MockMutableStateMockRecorder) ApplyMutation(mutation interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyRequestCancelExternalWorkflowExecutionFailedEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyRequestCancelExternalWorkflowExecutionFailedEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -1129,28 +1134,28 @@ func (m *MockMutableState) ApplyRequestCancelExternalWorkflowExecutionFailedEven
 }
 
 // ApplyRequestCancelExternalWorkflowExecutionFailedEvent indicates an expected call of ApplyRequestCancelExternalWorkflowExecutionFailedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyRequestCancelExternalWorkflowExecutionFailedEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent, arg2 string) (*v112.RequestCancelInfo, error) {
+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].(*v112.RequestCancelInfo)
+	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 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplySignalExternalWorkflowExecutionFailedEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplySignalExternalWorkflowExecutionFailedEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -1158,28 +1163,28 @@ func (m *MockMutableState) ApplySignalExternalWorkflowExecutionFailedEvent(arg0
 }
 
 // ApplySignalExternalWorkflowExecutionFailedEvent indicates an expected call of ApplySignalExternalWorkflowExecutionFailedEvent.
-func (mr *MockMutableStateMockRecorder) ApplySignalExternalWorkflowExecutionFailedEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent, arg2 string) (*v112.SignalInfo, error) {
+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].(*v112.SignalInfo)
+	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 interface{}) *gomock.Call {
+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 *v112.WorkflowMutableState) error {
+func (m *MockMutableState) ApplySnapshot(snapshot *persistence.WorkflowMutableState) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplySnapshot", snapshot)
 	ret0, _ := ret[0].(error)
@@ -1187,13 +1192,13 @@ func (m *MockMutableState) ApplySnapshot(snapshot *v112.WorkflowMutableState) er
 }
 
 // ApplySnapshot indicates an expected call of ApplySnapshot.
-func (mr *MockMutableStateMockRecorder) ApplySnapshot(snapshot interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyStartChildWorkflowExecutionFailedEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyStartChildWorkflowExecutionFailedEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -1201,28 +1206,28 @@ func (m *MockMutableState) ApplyStartChildWorkflowExecutionFailedEvent(arg0 *v13
 }
 
 // ApplyStartChildWorkflowExecutionFailedEvent indicates an expected call of ApplyStartChildWorkflowExecutionFailedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyStartChildWorkflowExecutionFailedEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent, arg2 string) (*v112.ChildExecutionInfo, error) {
+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].(*v112.ChildExecutionInfo)
+	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 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyTimerCanceledEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyTimerCanceledEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -1230,13 +1235,13 @@ func (m *MockMutableState) ApplyTimerCanceledEvent(arg0 *v13.HistoryEvent) error
 }
 
 // ApplyTimerCanceledEvent indicates an expected call of ApplyTimerCanceledEvent.
-func (mr *MockMutableStateMockRecorder) ApplyTimerCanceledEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyTimerFiredEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyTimerFiredEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -1244,22 +1249,22 @@ func (m *MockMutableState) ApplyTimerFiredEvent(arg0 *v13.HistoryEvent) error {
 }
 
 // ApplyTimerFiredEvent indicates an expected call of ApplyTimerFiredEvent.
-func (mr *MockMutableStateMockRecorder) ApplyTimerFiredEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) (*v112.TimerInfo, error) {
+func (m *MockMutableState) ApplyTimerStartedEvent(arg0 *history.HistoryEvent) (*persistence.TimerInfo, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyTimerStartedEvent", arg0)
-	ret0, _ := ret[0].(*v112.TimerInfo)
+	ret0, _ := ret[0].(*persistence.TimerInfo)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // ApplyTimerStartedEvent indicates an expected call of ApplyTimerStartedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyTimerStartedEvent(arg0 interface{}) *gomock.Call {
+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)
 }
@@ -1280,19 +1285,19 @@ func (mr *MockMutableStateMockRecorder) ApplyTransientWorkflowTaskScheduled() *g
 }
 
 // ApplyUpsertWorkflowSearchAttributesEvent mocks base method.
-func (m *MockMutableState) ApplyUpsertWorkflowSearchAttributesEvent(arg0 *v13.HistoryEvent) {
+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 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyWorkflowExecutionCancelRequestedEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyWorkflowExecutionCancelRequestedEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -1300,13 +1305,13 @@ func (m *MockMutableState) ApplyWorkflowExecutionCancelRequestedEvent(arg0 *v13.
 }
 
 // ApplyWorkflowExecutionCancelRequestedEvent indicates an expected call of ApplyWorkflowExecutionCancelRequestedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionCancelRequestedEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+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)
@@ -1314,13 +1319,13 @@ func (m *MockMutableState) ApplyWorkflowExecutionCanceledEvent(arg0 int64, arg1
 }
 
 // ApplyWorkflowExecutionCanceledEvent indicates an expected call of ApplyWorkflowExecutionCanceledEvent.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionCanceledEvent(arg0, arg1 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+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)
@@ -1328,13 +1333,13 @@ func (m *MockMutableState) ApplyWorkflowExecutionCompletedEvent(arg0 int64, arg1
 }
 
 // ApplyWorkflowExecutionCompletedEvent indicates an expected call of ApplyWorkflowExecutionCompletedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionCompletedEvent(arg0, arg1 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+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)
@@ -1342,13 +1347,13 @@ func (m *MockMutableState) ApplyWorkflowExecutionContinuedAsNewEvent(arg0 int64,
 }
 
 // ApplyWorkflowExecutionContinuedAsNewEvent indicates an expected call of ApplyWorkflowExecutionContinuedAsNewEvent.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionContinuedAsNewEvent(arg0, arg1 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+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)
@@ -1356,13 +1361,13 @@ func (m *MockMutableState) ApplyWorkflowExecutionFailedEvent(arg0 int64, arg1 *v
 }
 
 // ApplyWorkflowExecutionFailedEvent indicates an expected call of ApplyWorkflowExecutionFailedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionFailedEvent(arg0, arg1 interface{}) *gomock.Call {
+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)
 }
 
 // ApplyWorkflowExecutionSignaled mocks base method.
-func (m *MockMutableState) ApplyWorkflowExecutionSignaled(arg0 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyWorkflowExecutionSignaled(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyWorkflowExecutionSignaled", arg0)
 	ret0, _ := ret[0].(error)
@@ -1370,13 +1375,13 @@ func (m *MockMutableState) ApplyWorkflowExecutionSignaled(arg0 *v13.HistoryEvent
 }
 
 // ApplyWorkflowExecutionSignaled indicates an expected call of ApplyWorkflowExecutionSignaled.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionSignaled(arg0 interface{}) *gomock.Call {
+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 *v18.VectorClock, arg1 *v10.WorkflowExecution, arg2 string, arg3 *v13.HistoryEvent) error {
+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)
@@ -1384,13 +1389,13 @@ func (m *MockMutableState) ApplyWorkflowExecutionStartedEvent(arg0 *v18.VectorCl
 }
 
 // ApplyWorkflowExecutionStartedEvent indicates an expected call of ApplyWorkflowExecutionStartedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionStartedEvent(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+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)
@@ -1398,13 +1403,13 @@ func (m *MockMutableState) ApplyWorkflowExecutionTerminatedEvent(arg0 int64, arg
 }
 
 // ApplyWorkflowExecutionTerminatedEvent indicates an expected call of ApplyWorkflowExecutionTerminatedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionTerminatedEvent(arg0, arg1 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+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)
@@ -1412,13 +1417,13 @@ func (m *MockMutableState) ApplyWorkflowExecutionTimedoutEvent(arg0 int64, arg1
 }
 
 // ApplyWorkflowExecutionTimedoutEvent indicates an expected call of ApplyWorkflowExecutionTimedoutEvent.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionTimedoutEvent(arg0, arg1 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyWorkflowExecutionUpdateAcceptedEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyWorkflowExecutionUpdateAcceptedEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -1426,13 +1431,13 @@ func (m *MockMutableState) ApplyWorkflowExecutionUpdateAcceptedEvent(arg0 *v13.H
 }
 
 // ApplyWorkflowExecutionUpdateAcceptedEvent indicates an expected call of ApplyWorkflowExecutionUpdateAcceptedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionUpdateAcceptedEvent(arg0 interface{}) *gomock.Call {
+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 *v13.HistoryEvent, batchId int64) error {
+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)
@@ -1440,13 +1445,13 @@ func (m *MockMutableState) ApplyWorkflowExecutionUpdateAdmittedEvent(event *v13.
 }
 
 // ApplyWorkflowExecutionUpdateAdmittedEvent indicates an expected call of ApplyWorkflowExecutionUpdateAdmittedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionUpdateAdmittedEvent(event, batchId interface{}) *gomock.Call {
+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 *v13.HistoryEvent, batchID int64) error {
+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)
@@ -1454,25 +1459,25 @@ func (m *MockMutableState) ApplyWorkflowExecutionUpdateCompletedEvent(event *v13
 }
 
 // ApplyWorkflowExecutionUpdateCompletedEvent indicates an expected call of ApplyWorkflowExecutionUpdateCompletedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionUpdateCompletedEvent(event, batchID interface{}) *gomock.Call {
+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 *v13.HistoryEvent) {
+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 interface{}) *gomock.Call {
+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 *v13.HistoryEvent) error {
+func (m *MockMutableState) ApplyWorkflowTaskCompletedEvent(arg0 *history.HistoryEvent) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyWorkflowTaskCompletedEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -1480,7 +1485,7 @@ func (m *MockMutableState) ApplyWorkflowTaskCompletedEvent(arg0 *v13.HistoryEven
 }
 
 // ApplyWorkflowTaskCompletedEvent indicates an expected call of ApplyWorkflowTaskCompletedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowTaskCompletedEvent(arg0 interface{}) *gomock.Call {
+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)
 }
@@ -1500,7 +1505,7 @@ func (mr *MockMutableStateMockRecorder) ApplyWorkflowTaskFailedEvent() *gomock.C
 }
 
 // ApplyWorkflowTaskScheduledEvent mocks base method.
-func (m *MockMutableState) ApplyWorkflowTaskScheduledEvent(arg0, arg1 int64, arg2 *v14.TaskQueue, arg3 *durationpb.Duration, arg4 int32, arg5, arg6 *timestamppb.Timestamp, arg7 v19.WorkflowTaskType) (*WorkflowTaskInfo, error) {
+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)
@@ -1509,13 +1514,13 @@ func (m *MockMutableState) ApplyWorkflowTaskScheduledEvent(arg0, arg1 int64, arg
 }
 
 // ApplyWorkflowTaskScheduledEvent indicates an expected call of ApplyWorkflowTaskScheduledEvent.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowTaskScheduledEvent(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 interface{}) *gomock.Call {
+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 *v10.WorkerVersionStamp, arg9 int64) (*WorkflowTaskInfo, error) {
+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)
@@ -1524,13 +1529,13 @@ func (m *MockMutableState) ApplyWorkflowTaskStartedEvent(arg0 *WorkflowTaskInfo,
 }
 
 // ApplyWorkflowTaskStartedEvent indicates an expected call of ApplyWorkflowTaskStartedEvent.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowTaskStartedEvent(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 interface{}) *gomock.Call {
+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 v11.TimeoutType) error {
+func (m *MockMutableState) ApplyWorkflowTaskTimedOutEvent(arg0 enums.TimeoutType) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ApplyWorkflowTaskTimedOutEvent", arg0)
 	ret0, _ := ret[0].(error)
@@ -1538,7 +1543,7 @@ func (m *MockMutableState) ApplyWorkflowTaskTimedOutEvent(arg0 v11.TimeoutType)
 }
 
 // ApplyWorkflowTaskTimedOutEvent indicates an expected call of ApplyWorkflowTaskTimedOutEvent.
-func (mr *MockMutableStateMockRecorder) ApplyWorkflowTaskTimedOutEvent(arg0 interface{}) *gomock.Call {
+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)
 }
@@ -1566,7 +1571,7 @@ func (m *MockMutableState) CheckSpeculativeWorkflowTaskTimeoutTask(task *tasks.W
 }
 
 // CheckSpeculativeWorkflowTaskTimeoutTask indicates an expected call of CheckSpeculativeWorkflowTaskTimeoutTask.
-func (mr *MockMutableStateMockRecorder) CheckSpeculativeWorkflowTaskTimeoutTask(task interface{}) *gomock.Call {
+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)
 }
@@ -1598,10 +1603,10 @@ func (mr *MockMutableStateMockRecorder) ClearTransientWorkflowTask() *gomock.Cal
 }
 
 // CloneToProto mocks base method.
-func (m *MockMutableState) CloneToProto() *v112.WorkflowMutableState {
+func (m *MockMutableState) CloneToProto() *persistence.WorkflowMutableState {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CloneToProto")
-	ret0, _ := ret[0].(*v112.WorkflowMutableState)
+	ret0, _ := ret[0].(*persistence.WorkflowMutableState)
 	return ret0
 }
 
@@ -1612,33 +1617,33 @@ func (mr *MockMutableStateMockRecorder) CloneToProto() *gomock.Call {
 }
 
 // CloseTransactionAsMutation mocks base method.
-func (m *MockMutableState) CloseTransactionAsMutation(transactionPolicy TransactionPolicy) (*persistence.WorkflowMutation, []*persistence.WorkflowEvents, error) {
+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].(*persistence.WorkflowMutation)
-	ret1, _ := ret[1].([]*persistence.WorkflowEvents)
+	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 interface{}) *gomock.Call {
+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) (*persistence.WorkflowSnapshot, []*persistence.WorkflowEvents, error) {
+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].(*persistence.WorkflowSnapshot)
-	ret1, _ := ret[1].([]*persistence.WorkflowEvents)
+	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 interface{}) *gomock.Call {
+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)
 }
@@ -1652,16 +1657,16 @@ func (m *MockMutableState) ContinueAsNewMinBackoff(backoffDuration *durationpb.D
 }
 
 // ContinueAsNewMinBackoff indicates an expected call of ContinueAsNewMinBackoff.
-func (mr *MockMutableStateMockRecorder) ContinueAsNewMinBackoff(backoffDuration interface{}) *gomock.Call {
+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() *v14.TaskQueue {
+func (m *MockMutableState) CurrentTaskQueue() *taskqueue.TaskQueue {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CurrentTaskQueue")
-	ret0, _ := ret[0].(*v14.TaskQueue)
+	ret0, _ := ret[0].(*taskqueue.TaskQueue)
 	return ret0
 }
 
@@ -1678,7 +1683,7 @@ func (m *MockMutableState) DeleteSignalRequested(requestID string) {
 }
 
 // DeleteSignalRequested indicates an expected call of DeleteSignalRequested.
-func (mr *MockMutableStateMockRecorder) DeleteSignalRequested(requestID interface{}) *gomock.Call {
+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)
 }
@@ -1712,77 +1717,77 @@ func (mr *MockMutableStateMockRecorder) GenerateMigrationTasks() *gomock.Call {
 }
 
 // GetActivityByActivityID mocks base method.
-func (m *MockMutableState) GetActivityByActivityID(arg0 string) (*v112.ActivityInfo, bool) {
+func (m *MockMutableState) GetActivityByActivityID(arg0 string) (*persistence.ActivityInfo, bool) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetActivityByActivityID", arg0)
-	ret0, _ := ret[0].(*v112.ActivityInfo)
+	ret0, _ := ret[0].(*persistence.ActivityInfo)
 	ret1, _ := ret[1].(bool)
 	return ret0, ret1
 }
 
 // GetActivityByActivityID indicates an expected call of GetActivityByActivityID.
-func (mr *MockMutableStateMockRecorder) GetActivityByActivityID(arg0 interface{}) *gomock.Call {
+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) (*v112.ActivityInfo, bool) {
+func (m *MockMutableState) GetActivityInfo(arg0 int64) (*persistence.ActivityInfo, bool) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetActivityInfo", arg0)
-	ret0, _ := ret[0].(*v112.ActivityInfo)
+	ret0, _ := ret[0].(*persistence.ActivityInfo)
 	ret1, _ := ret[1].(bool)
 	return ret0, ret1
 }
 
 // GetActivityInfo indicates an expected call of GetActivityInfo.
-func (mr *MockMutableStateMockRecorder) GetActivityInfo(arg0 interface{}) *gomock.Call {
+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) (*v112.ActivityInfo, time.Time, bool) {
+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].(*v112.ActivityInfo)
+	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 interface{}) *gomock.Call {
+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) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v112.ActivityInfo) (*v10.ActivityType, error) {
+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].(*v10.ActivityType)
+	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 interface{}) *gomock.Call {
+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)
 }
@@ -1816,10 +1821,10 @@ func (mr *MockMutableStateMockRecorder) GetAssignedBuildId() *gomock.Call {
 }
 
 // GetBaseWorkflowInfo mocks base method.
-func (m *MockMutableState) GetBaseWorkflowInfo() *v114.BaseExecutionInfo {
+func (m *MockMutableState) GetBaseWorkflowInfo() *workflow0.BaseExecutionInfo {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetBaseWorkflowInfo")
-	ret0, _ := ret[0].(*v114.BaseExecutionInfo)
+	ret0, _ := ret[0].(*workflow0.BaseExecutionInfo)
 	return ret0
 }
 
@@ -1830,31 +1835,31 @@ func (mr *MockMutableStateMockRecorder) GetBaseWorkflowInfo() *gomock.Call {
 }
 
 // GetChildExecutionInfo mocks base method.
-func (m *MockMutableState) GetChildExecutionInfo(arg0 int64) (*v112.ChildExecutionInfo, bool) {
+func (m *MockMutableState) GetChildExecutionInfo(arg0 int64) (*persistence.ChildExecutionInfo, bool) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetChildExecutionInfo", arg0)
-	ret0, _ := ret[0].(*v112.ChildExecutionInfo)
+	ret0, _ := ret[0].(*persistence.ChildExecutionInfo)
 	ret1, _ := ret[1].(bool)
 	return ret0, ret1
 }
 
 // GetChildExecutionInfo indicates an expected call of GetChildExecutionInfo.
-func (mr *MockMutableStateMockRecorder) GetChildExecutionInfo(arg0 interface{}) *gomock.Call {
+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) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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)
 }
@@ -1875,16 +1880,16 @@ func (mr *MockMutableStateMockRecorder) GetCloseVersion() *gomock.Call {
 }
 
 // GetCompletionEvent mocks base method.
-func (m *MockMutableState) GetCompletionEvent(arg0 context.Context) (*v13.HistoryEvent, error) {
+func (m *MockMutableState) GetCompletionEvent(arg0 context.Context) (*history.HistoryEvent, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetCompletionEvent", arg0)
-	ret0, _ := ret[0].(*v13.HistoryEvent)
+	ret0, _ := ret[0].(*history.HistoryEvent)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // GetCompletionEvent indicates an expected call of GetCompletionEvent.
-func (mr *MockMutableStateMockRecorder) GetCompletionEvent(arg0 interface{}) *gomock.Call {
+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)
 }
@@ -1933,10 +1938,10 @@ func (mr *MockMutableStateMockRecorder) GetCurrentVersion() *gomock.Call {
 }
 
 // GetExecutionInfo mocks base method.
-func (m *MockMutableState) GetExecutionInfo() *v112.WorkflowExecutionInfo {
+func (m *MockMutableState) GetExecutionInfo() *persistence.WorkflowExecutionInfo {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetExecutionInfo")
-	ret0, _ := ret[0].(*v112.WorkflowExecutionInfo)
+	ret0, _ := ret[0].(*persistence.WorkflowExecutionInfo)
 	return ret0
 }
 
@@ -1947,10 +1952,10 @@ func (mr *MockMutableStateMockRecorder) GetExecutionInfo() *gomock.Call {
 }
 
 // GetExecutionState mocks base method.
-func (m *MockMutableState) GetExecutionState() *v112.WorkflowExecutionState {
+func (m *MockMutableState) GetExecutionState() *persistence.WorkflowExecutionState {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetExecutionState")
-	ret0, _ := ret[0].(*v112.WorkflowExecutionState)
+	ret0, _ := ret[0].(*persistence.WorkflowExecutionState)
 	return ret0
 }
 
@@ -1970,22 +1975,22 @@ func (m *MockMutableState) GetFirstRunID(ctx context.Context) (string, error) {
 }
 
 // GetFirstRunID indicates an expected call of GetFirstRunID.
-func (mr *MockMutableStateMockRecorder) GetFirstRunID(ctx interface{}) *gomock.Call {
+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) (*v112.HSMCompletionCallbackArg, error) {
+func (m *MockMutableState) GetHSMCompletionCallbackArg(ctx context.Context) (*persistence.HSMCompletionCallbackArg, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetHSMCompletionCallbackArg", ctx)
-	ret0, _ := ret[0].(*v112.HSMCompletionCallbackArg)
+	ret0, _ := ret[0].(*persistence.HSMCompletionCallbackArg)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // GetHSMCompletionCallbackArg indicates an expected call of GetHSMCompletionCallbackArg.
-func (mr *MockMutableStateMockRecorder) GetHSMCompletionCallbackArg(ctx interface{}) *gomock.Call {
+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)
 }
@@ -2078,10 +2083,10 @@ func (mr *MockMutableStateMockRecorder) GetLastWriteVersion() *gomock.Call {
 }
 
 // GetMostRecentWorkerVersionStamp mocks base method.
-func (m *MockMutableState) GetMostRecentWorkerVersionStamp() *v10.WorkerVersionStamp {
+func (m *MockMutableState) GetMostRecentWorkerVersionStamp() *common.WorkerVersionStamp {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetMostRecentWorkerVersionStamp")
-	ret0, _ := ret[0].(*v10.WorkerVersionStamp)
+	ret0, _ := ret[0].(*common.WorkerVersionStamp)
 	return ret0
 }
 
@@ -2129,16 +2134,16 @@ func (m *MockMutableState) GetNexusCompletion(ctx context.Context) (nexus.Operat
 }
 
 // GetNexusCompletion indicates an expected call of GetNexusCompletion.
-func (mr *MockMutableStateMockRecorder) GetNexusCompletion(ctx interface{}) *gomock.Call {
+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]*v112.ActivityInfo {
+func (m *MockMutableState) GetPendingActivityInfos() map[int64]*persistence.ActivityInfo {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetPendingActivityInfos")
-	ret0, _ := ret[0].(map[int64]*v112.ActivityInfo)
+	ret0, _ := ret[0].(map[int64]*persistence.ActivityInfo)
 	return ret0
 }
 
@@ -2149,10 +2154,10 @@ func (mr *MockMutableStateMockRecorder) GetPendingActivityInfos() *gomock.Call {
 }
 
 // GetPendingChildExecutionInfos mocks base method.
-func (m *MockMutableState) GetPendingChildExecutionInfos() map[int64]*v112.ChildExecutionInfo {
+func (m *MockMutableState) GetPendingChildExecutionInfos() map[int64]*persistence.ChildExecutionInfo {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetPendingChildExecutionInfos")
-	ret0, _ := ret[0].(map[int64]*v112.ChildExecutionInfo)
+	ret0, _ := ret[0].(map[int64]*persistence.ChildExecutionInfo)
 	return ret0
 }
 
@@ -2163,10 +2168,10 @@ func (mr *MockMutableStateMockRecorder) GetPendingChildExecutionInfos() *gomock.
 }
 
 // GetPendingRequestCancelExternalInfos mocks base method.
-func (m *MockMutableState) GetPendingRequestCancelExternalInfos() map[int64]*v112.RequestCancelInfo {
+func (m *MockMutableState) GetPendingRequestCancelExternalInfos() map[int64]*persistence.RequestCancelInfo {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetPendingRequestCancelExternalInfos")
-	ret0, _ := ret[0].(map[int64]*v112.RequestCancelInfo)
+	ret0, _ := ret[0].(map[int64]*persistence.RequestCancelInfo)
 	return ret0
 }
 
@@ -2177,10 +2182,10 @@ func (mr *MockMutableStateMockRecorder) GetPendingRequestCancelExternalInfos() *
 }
 
 // GetPendingSignalExternalInfos mocks base method.
-func (m *MockMutableState) GetPendingSignalExternalInfos() map[int64]*v112.SignalInfo {
+func (m *MockMutableState) GetPendingSignalExternalInfos() map[int64]*persistence.SignalInfo {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetPendingSignalExternalInfos")
-	ret0, _ := ret[0].(map[int64]*v112.SignalInfo)
+	ret0, _ := ret[0].(map[int64]*persistence.SignalInfo)
 	return ret0
 }
 
@@ -2205,10 +2210,10 @@ func (mr *MockMutableStateMockRecorder) GetPendingSignalRequestedIds() *gomock.C
 }
 
 // GetPendingTimerInfos mocks base method.
-func (m *MockMutableState) GetPendingTimerInfos() map[string]*v112.TimerInfo {
+func (m *MockMutableState) GetPendingTimerInfos() map[string]*persistence.TimerInfo {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetPendingTimerInfos")
-	ret0, _ := ret[0].(map[string]*v112.TimerInfo)
+	ret0, _ := ret[0].(map[string]*persistence.TimerInfo)
 	return ret0
 }
 
@@ -2247,91 +2252,91 @@ func (mr *MockMutableStateMockRecorder) GetQueryRegistry() *gomock.Call {
 }
 
 // GetRequestCancelInfo mocks base method.
-func (m *MockMutableState) GetRequestCancelInfo(arg0 int64) (*v112.RequestCancelInfo, bool) {
+func (m *MockMutableState) GetRequestCancelInfo(arg0 int64) (*persistence.RequestCancelInfo, bool) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetRequestCancelInfo", arg0)
-	ret0, _ := ret[0].(*v112.RequestCancelInfo)
+	ret0, _ := ret[0].(*persistence.RequestCancelInfo)
 	ret1, _ := ret[1].(bool)
 	return ret0, ret1
 }
 
 // GetRequestCancelInfo indicates an expected call of GetRequestCancelInfo.
-func (mr *MockMutableStateMockRecorder) GetRequestCancelInfo(arg0 interface{}) *gomock.Call {
+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) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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 *v12.Failure) (time.Duration, v11.RetryState) {
+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].(v11.RetryState)
+	ret1, _ := ret[1].(enums.RetryState)
 	return ret0, ret1
 }
 
 // GetRetryBackoffDuration indicates an expected call of GetRetryBackoffDuration.
-func (mr *MockMutableStateMockRecorder) GetRetryBackoffDuration(failure interface{}) *gomock.Call {
+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) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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) (*v112.SignalInfo, bool) {
+func (m *MockMutableState) GetSignalInfo(arg0 int64) (*persistence.SignalInfo, bool) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetSignalInfo", arg0)
-	ret0, _ := ret[0].(*v112.SignalInfo)
+	ret0, _ := ret[0].(*persistence.SignalInfo)
 	ret1, _ := ret[1].(bool)
 	return ret0, ret1
 }
 
 // GetSignalInfo indicates an expected call of GetSignalInfo.
-func (mr *MockMutableStateMockRecorder) GetSignalInfo(arg0 interface{}) *gomock.Call {
+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) (*v13.HistoryEvent, error) {
+func (m *MockMutableState) GetStartEvent(arg0 context.Context) (*history.HistoryEvent, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetStartEvent", arg0)
-	ret0, _ := ret[0].(*v13.HistoryEvent)
+	ret0, _ := ret[0].(*history.HistoryEvent)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // GetStartEvent indicates an expected call of GetStartEvent.
-func (mr *MockMutableStateMockRecorder) GetStartEvent(arg0 interface{}) *gomock.Call {
+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)
 }
@@ -2366,15 +2371,15 @@ func (mr *MockMutableStateMockRecorder) GetStartedWorkflowTask() *gomock.Call {
 }
 
 // GetTransientWorkflowTaskInfo mocks base method.
-func (m *MockMutableState) GetTransientWorkflowTaskInfo(workflowTask *WorkflowTaskInfo, identity string) *v110.TransientWorkflowTaskInfo {
+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].(*v110.TransientWorkflowTaskInfo)
+	ret0, _ := ret[0].(*history0.TransientWorkflowTaskInfo)
 	return ret0
 }
 
 // GetTransientWorkflowTaskInfo indicates an expected call of GetTransientWorkflowTaskInfo.
-func (mr *MockMutableStateMockRecorder) GetTransientWorkflowTaskInfo(workflowTask, identity interface{}) *gomock.Call {
+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)
 }
@@ -2395,46 +2400,46 @@ func (mr *MockMutableStateMockRecorder) GetUpdateCondition() *gomock.Call {
 }
 
 // GetUpdateOutcome mocks base method.
-func (m *MockMutableState) GetUpdateOutcome(ctx context.Context, updateID string) (*v15.Outcome, error) {
+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].(*v15.Outcome)
+	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 interface{}) *gomock.Call {
+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) (*v112.TimerInfo, bool) {
+func (m *MockMutableState) GetUserTimerInfo(arg0 string) (*persistence.TimerInfo, bool) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetUserTimerInfo", arg0)
-	ret0, _ := ret[0].(*v112.TimerInfo)
+	ret0, _ := ret[0].(*persistence.TimerInfo)
 	ret1, _ := ret[1].(bool)
 	return ret0, ret1
 }
 
 // GetUserTimerInfo indicates an expected call of GetUserTimerInfo.
-func (mr *MockMutableStateMockRecorder) GetUserTimerInfo(arg0 interface{}) *gomock.Call {
+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) (*v112.TimerInfo, bool) {
+func (m *MockMutableState) GetUserTimerInfoByEventID(arg0 int64) (*persistence.TimerInfo, bool) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetUserTimerInfoByEventID", arg0)
-	ret0, _ := ret[0].(*v112.TimerInfo)
+	ret0, _ := ret[0].(*persistence.TimerInfo)
 	ret1, _ := ret[1].(bool)
 	return ret0, ret1
 }
 
 // GetUserTimerInfoByEventID indicates an expected call of GetUserTimerInfoByEventID.
-func (mr *MockMutableStateMockRecorder) GetUserTimerInfoByEventID(arg0 interface{}) *gomock.Call {
+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)
 }
@@ -2449,7 +2454,7 @@ func (m *MockMutableState) GetWorkflowCloseTime(ctx context.Context) (time.Time,
 }
 
 // GetWorkflowCloseTime indicates an expected call of GetWorkflowCloseTime.
-func (mr *MockMutableStateMockRecorder) GetWorkflowCloseTime(ctx interface{}) *gomock.Call {
+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)
 }
@@ -2464,7 +2469,7 @@ func (m *MockMutableState) GetWorkflowExecutionDuration(ctx context.Context) (ti
 }
 
 // GetWorkflowExecutionDuration indicates an expected call of GetWorkflowExecutionDuration.
-func (mr *MockMutableStateMockRecorder) GetWorkflowExecutionDuration(ctx interface{}) *gomock.Call {
+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)
 }
@@ -2484,11 +2489,11 @@ func (mr *MockMutableStateMockRecorder) GetWorkflowKey() *gomock.Call {
 }
 
 // GetWorkflowStateStatus mocks base method.
-func (m *MockMutableState) GetWorkflowStateStatus() (v19.WorkflowExecutionState, v11.WorkflowExecutionStatus) {
+func (m *MockMutableState) GetWorkflowStateStatus() (enums0.WorkflowExecutionState, enums.WorkflowExecutionStatus) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetWorkflowStateStatus")
-	ret0, _ := ret[0].(v19.WorkflowExecutionState)
-	ret1, _ := ret[1].(v11.WorkflowExecutionStatus)
+	ret0, _ := ret[0].(enums0.WorkflowExecutionState)
+	ret1, _ := ret[1].(enums.WorkflowExecutionStatus)
 	return ret0, ret1
 }
 
@@ -2507,16 +2512,16 @@ func (m *MockMutableState) GetWorkflowTaskByID(scheduledEventID int64) *Workflow
 }
 
 // GetWorkflowTaskByID indicates an expected call of GetWorkflowTaskByID.
-func (mr *MockMutableStateMockRecorder) GetWorkflowTaskByID(scheduledEventID interface{}) *gomock.Call {
+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() *v10.WorkflowType {
+func (m *MockMutableState) GetWorkflowType() *common.WorkflowType {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetWorkflowType")
-	ret0, _ := ret[0].(*v10.WorkflowType)
+	ret0, _ := ret[0].(*common.WorkflowType)
 	return ret0
 }
 
@@ -2563,7 +2568,7 @@ func (m *MockMutableState) HasAnyBufferedEvent(filter historybuilder.BufferedEve
 }
 
 // HasAnyBufferedEvent indicates an expected call of HasAnyBufferedEvent.
-func (mr *MockMutableStateMockRecorder) HasAnyBufferedEvent(filter interface{}) *gomock.Call {
+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)
 }
@@ -2701,7 +2706,7 @@ func (m *MockMutableState) IsResourceDuplicated(resourceDedupKey definition.Dedu
 }
 
 // IsResourceDuplicated indicates an expected call of IsResourceDuplicated.
-func (mr *MockMutableStateMockRecorder) IsResourceDuplicated(resourceDedupKey interface{}) *gomock.Call {
+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)
 }
@@ -2715,7 +2720,7 @@ func (m *MockMutableState) IsSignalRequested(requestID string) bool {
 }
 
 // IsSignalRequested indicates an expected call of IsSignalRequested.
-func (mr *MockMutableStateMockRecorder) IsSignalRequested(requestID interface{}) *gomock.Call {
+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)
 }
@@ -2805,16 +2810,16 @@ func (mr *MockMutableStateMockRecorder) IsWorkflowPendingOnWorkflowTaskBackoff()
 }
 
 // LoadHistoryEvent mocks base method.
-func (m *MockMutableState) LoadHistoryEvent(ctx context.Context, token []byte) (*v13.HistoryEvent, error) {
+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].(*v13.HistoryEvent)
+	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 interface{}) *gomock.Call {
+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)
 }
@@ -2848,13 +2853,13 @@ func (mr *MockMutableStateMockRecorder) PopTasks() *gomock.Call {
 }
 
 // RecordLastActivityStarted mocks base method.
-func (m *MockMutableState) RecordLastActivityStarted(ai *v112.ActivityInfo) {
+func (m *MockMutableState) RecordLastActivityStarted(ai *persistence.ActivityInfo) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "RecordLastActivityStarted", ai)
 }
 
 // RecordLastActivityStarted indicates an expected call of RecordLastActivityStarted.
-func (mr *MockMutableStateMockRecorder) RecordLastActivityStarted(ai interface{}) *gomock.Call {
+func (mr *MockMutableStateMockRecorder) RecordLastActivityStarted(ai any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordLastActivityStarted", reflect.TypeOf((*MockMutableState)(nil).RecordLastActivityStarted), ai)
 }
@@ -2868,13 +2873,13 @@ func (m *MockMutableState) RefreshExpirationTimeoutTask(ctx context.Context) err
 }
 
 // RefreshExpirationTimeoutTask indicates an expected call of RefreshExpirationTimeoutTask.
-func (mr *MockMutableStateMockRecorder) RefreshExpirationTimeoutTask(ctx interface{}) *gomock.Call {
+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 *v112.ActivityInfo) error {
+func (m *MockMutableState) RegenerateActivityRetryTask(ai *persistence.ActivityInfo) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RegenerateActivityRetryTask", ai)
 	ret0, _ := ret[0].(error)
@@ -2882,13 +2887,13 @@ func (m *MockMutableState) RegenerateActivityRetryTask(ai *v112.ActivityInfo) er
 }
 
 // RegenerateActivityRetryTask indicates an expected call of RegenerateActivityRetryTask.
-func (mr *MockMutableStateMockRecorder) RegenerateActivityRetryTask(ai interface{}) *gomock.Call {
+func (mr *MockMutableStateMockRecorder) RegenerateActivityRetryTask(ai any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegenerateActivityRetryTask", reflect.TypeOf((*MockMutableState)(nil).RegenerateActivityRetryTask), ai)
 }
 
 // RejectWorkflowExecutionUpdate mocks base method.
-func (m *MockMutableState) RejectWorkflowExecutionUpdate(protocolInstanceID string, updRejection *v15.Rejection) error {
+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)
@@ -2896,7 +2901,7 @@ func (m *MockMutableState) RejectWorkflowExecutionUpdate(protocolInstanceID stri
 }
 
 // RejectWorkflowExecutionUpdate indicates an expected call of RejectWorkflowExecutionUpdate.
-func (mr *MockMutableStateMockRecorder) RejectWorkflowExecutionUpdate(protocolInstanceID, updRejection interface{}) *gomock.Call {
+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)
 }
@@ -2914,16 +2919,16 @@ func (mr *MockMutableStateMockRecorder) RemoveSpeculativeWorkflowTaskTimeoutTask
 }
 
 // RetryActivity mocks base method.
-func (m *MockMutableState) RetryActivity(ai *v112.ActivityInfo, failure *v12.Failure) (v11.RetryState, error) {
+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].(v11.RetryState)
+	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 interface{}) *gomock.Call {
+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)
 }
@@ -2935,7 +2940,7 @@ func (m *MockMutableState) SetBaseWorkflow(baseRunID string, baseRunLowestCommon
 }
 
 // SetBaseWorkflow indicates an expected call of SetBaseWorkflow.
-func (mr *MockMutableStateMockRecorder) SetBaseWorkflow(baseRunID, baseRunLowestCommonAncestorEventID, baseRunLowestCommonAncestorEventVersion interface{}) *gomock.Call {
+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)
 }
@@ -2949,7 +2954,7 @@ func (m *MockMutableState) SetCurrentBranchToken(branchToken []byte) error {
 }
 
 // SetCurrentBranchToken indicates an expected call of SetCurrentBranchToken.
-func (mr *MockMutableStateMockRecorder) SetCurrentBranchToken(branchToken interface{}) *gomock.Call {
+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)
 }
@@ -2961,7 +2966,7 @@ func (m *MockMutableState) SetHistoryBuilder(hBuilder *historybuilder.HistoryBui
 }
 
 // SetHistoryBuilder indicates an expected call of SetHistoryBuilder.
-func (mr *MockMutableStateMockRecorder) SetHistoryBuilder(hBuilder interface{}) *gomock.Call {
+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)
 }
@@ -2975,7 +2980,7 @@ func (m *MockMutableState) SetHistoryTree(executionTimeout, runTimeout *duration
 }
 
 // SetHistoryTree indicates an expected call of SetHistoryTree.
-func (mr *MockMutableStateMockRecorder) SetHistoryTree(executionTimeout, runTimeout, treeID interface{}) *gomock.Call {
+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)
 }
@@ -2989,7 +2994,7 @@ func (m *MockMutableState) SetSpeculativeWorkflowTaskTimeoutTask(task *tasks.Wor
 }
 
 // SetSpeculativeWorkflowTaskTimeoutTask indicates an expected call of SetSpeculativeWorkflowTaskTimeoutTask.
-func (mr *MockMutableStateMockRecorder) SetSpeculativeWorkflowTaskTimeoutTask(task interface{}) *gomock.Call {
+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)
 }
@@ -3001,7 +3006,7 @@ func (m *MockMutableState) SetStickyTaskQueue(name string, scheduleToStartTimeou
 }
 
 // SetStickyTaskQueue indicates an expected call of SetStickyTaskQueue.
-func (mr *MockMutableStateMockRecorder) SetStickyTaskQueue(name, scheduleToStartTimeout interface{}) *gomock.Call {
+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)
 }
@@ -3013,13 +3018,13 @@ func (m *MockMutableState) SetUpdateCondition(arg0, arg1 int64) {
 }
 
 // SetUpdateCondition indicates an expected call of SetUpdateCondition.
-func (mr *MockMutableStateMockRecorder) SetUpdateCondition(arg0, arg1 interface{}) *gomock.Call {
+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 *v112.ActivityInfo) bool {
+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)
@@ -3027,7 +3032,7 @@ func (m *MockMutableState) ShouldResetActivityTimerTaskMask(current, incoming *v
 }
 
 // ShouldResetActivityTimerTaskMask indicates an expected call of ShouldResetActivityTimerTaskMask.
-func (mr *MockMutableStateMockRecorder) ShouldResetActivityTimerTaskMask(current, incoming interface{}) *gomock.Call {
+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)
 }
@@ -3042,28 +3047,28 @@ func (m *MockMutableState) StartTransaction(entry *namespace.Namespace) (bool, e
 }
 
 // StartTransaction indicates an expected call of StartTransaction.
-func (mr *MockMutableStateMockRecorder) StartTransaction(entry interface{}) *gomock.Call {
+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) (*v14.TaskQueue, *durationpb.Duration) {
+func (m *MockMutableState) TaskQueueScheduleToStartTimeout(name string) (*taskqueue.TaskQueue, *durationpb.Duration) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "TaskQueueScheduleToStartTimeout", name)
-	ret0, _ := ret[0].(*v14.TaskQueue)
+	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 interface{}) *gomock.Call {
+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 *v112.ActivityInfo) error {
+func (m *MockMutableState) UpdateActivity(arg0 *persistence.ActivityInfo) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "UpdateActivity", arg0)
 	ret0, _ := ret[0].(error)
@@ -3071,13 +3076,13 @@ func (m *MockMutableState) UpdateActivity(arg0 *v112.ActivityInfo) error {
 }
 
 // UpdateActivity indicates an expected call of UpdateActivity.
-func (mr *MockMutableStateMockRecorder) UpdateActivity(arg0 interface{}) *gomock.Call {
+func (mr *MockMutableStateMockRecorder) UpdateActivity(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateActivity", reflect.TypeOf((*MockMutableState)(nil).UpdateActivity), arg0)
 }
 
 // UpdateActivityInfo mocks base method.
-func (m *MockMutableState) UpdateActivityInfo(arg0 *v111.ActivitySyncInfo, arg1 bool) error {
+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)
@@ -3085,25 +3090,25 @@ func (m *MockMutableState) UpdateActivityInfo(arg0 *v111.ActivitySyncInfo, arg1
 }
 
 // UpdateActivityInfo indicates an expected call of UpdateActivityInfo.
-func (mr *MockMutableStateMockRecorder) UpdateActivityInfo(arg0, arg1 interface{}) *gomock.Call {
+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 *v112.ActivityInfo, request *v17.RecordActivityTaskHeartbeatRequest) {
+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 interface{}) *gomock.Call {
+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)
 }
 
 // UpdateActivityWithTimerHeartbeat mocks base method.
-func (m *MockMutableState) UpdateActivityWithTimerHeartbeat(arg0 *v112.ActivityInfo, arg1 time.Time) error {
+func (m *MockMutableState) UpdateActivityWithTimerHeartbeat(arg0 *persistence.ActivityInfo, arg1 time.Time) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "UpdateActivityWithTimerHeartbeat", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -3111,7 +3116,7 @@ func (m *MockMutableState) UpdateActivityWithTimerHeartbeat(arg0 *v112.ActivityI
 }
 
 // UpdateActivityWithTimerHeartbeat indicates an expected call of UpdateActivityWithTimerHeartbeat.
-func (mr *MockMutableStateMockRecorder) UpdateActivityWithTimerHeartbeat(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockMutableStateMockRecorder) UpdateActivityWithTimerHeartbeat(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateActivityWithTimerHeartbeat", reflect.TypeOf((*MockMutableState)(nil).UpdateActivityWithTimerHeartbeat), arg0, arg1)
 }
@@ -3125,7 +3130,7 @@ func (m *MockMutableState) UpdateBuildIdAssignment(buildId string) error {
 }
 
 // UpdateBuildIdAssignment indicates an expected call of UpdateBuildIdAssignment.
-func (mr *MockMutableStateMockRecorder) UpdateBuildIdAssignment(buildId interface{}) *gomock.Call {
+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)
 }
@@ -3139,7 +3144,7 @@ func (m *MockMutableState) UpdateCurrentVersion(version int64, forceUpdate bool)
 }
 
 // UpdateCurrentVersion indicates an expected call of UpdateCurrentVersion.
-func (mr *MockMutableStateMockRecorder) UpdateCurrentVersion(version, forceUpdate interface{}) *gomock.Call {
+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)
 }
@@ -3151,7 +3156,7 @@ func (m *MockMutableState) UpdateDuplicatedResource(resourceDedupKey definition.
 }
 
 // UpdateDuplicatedResource indicates an expected call of UpdateDuplicatedResource.
-func (mr *MockMutableStateMockRecorder) UpdateDuplicatedResource(resourceDedupKey interface{}) *gomock.Call {
+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)
 }
@@ -3163,13 +3168,13 @@ func (m *MockMutableState) UpdateResetRunID(runID string) {
 }
 
 // UpdateResetRunID indicates an expected call of UpdateResetRunID.
-func (mr *MockMutableStateMockRecorder) UpdateResetRunID(runID interface{}) *gomock.Call {
+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 *v112.TimerInfo) error {
+func (m *MockMutableState) UpdateUserTimer(arg0 *persistence.TimerInfo) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "UpdateUserTimer", arg0)
 	ret0, _ := ret[0].(error)
@@ -3177,13 +3182,13 @@ func (m *MockMutableState) UpdateUserTimer(arg0 *v112.TimerInfo) error {
 }
 
 // UpdateUserTimer indicates an expected call of UpdateUserTimer.
-func (mr *MockMutableStateMockRecorder) UpdateUserTimer(arg0 interface{}) *gomock.Call {
+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)
 }
 
 // UpdateWorkflowStateStatus mocks base method.
-func (m *MockMutableState) UpdateWorkflowStateStatus(state v19.WorkflowExecutionState, status v11.WorkflowExecutionStatus) error {
+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)
@@ -3191,19 +3196,19 @@ func (m *MockMutableState) UpdateWorkflowStateStatus(state v19.WorkflowExecution
 }
 
 // UpdateWorkflowStateStatus indicates an expected call of UpdateWorkflowStateStatus.
-func (mr *MockMutableStateMockRecorder) UpdateWorkflowStateStatus(state, status interface{}) *gomock.Call {
+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, *v112.UpdateInfo)) {
+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 interface{}) *gomock.Call {
+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)
 }
diff --git a/service/history/workflow/workflow_test/mutable_state_impl_test.go b/service/history/workflow/workflow_test/mutable_state_impl_test.go
index 30898d7200f..d92fc58b281 100644
--- a/service/history/workflow/workflow_test/mutable_state_impl_test.go
+++ b/service/history/workflow/workflow_test/mutable_state_impl_test.go
@@ -205,7 +205,6 @@ func addWorkflowExecutionSignaled(t *testing.T, i int, ms *workflow.MutableState
 		payload,
 		identity,
 		header,
-		false,
 		nil,
 	)
 	if err != nil {