diff --git a/Makefile b/Makefile
index 29365795..705da44a 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,8 @@
 RELEASE_VERSION  =v1.0.0-rc-3
 GDOC_PORT        =8888
 GO_COMPAT_VERSION=1.21
+MOCKGEN_FORK     =go.uber.org/mock/mockgen
+MOCKGEN_VERSION  =v0.4.0
 
 .PHONY: all
 all: help
@@ -57,3 +59,11 @@ check-diff:
 .PHONY: modtidy
 modtidy:
 	go mod tidy
+
+.PHONY: mock
+mock: ## Generates mock files
+	go get $(MOCKGEN_FORK)@$(MOCKGEN_VERSION)
+	mockgen -source ./actor/manager/manager.go -destination ./actor/mock/mock_manager.go -package mock
+	mockgen -source ./actor/manager/container.go -destination ./actor/mock/mock_container.go -package mock
+	mockgen -source ./actor/codec/codec.go -destination ./actor/mock/mock_codec.go -package mock
+	mockgen -source ./client/client.go -destination ./actor/mock_client/mock_client.go -package mock_client
diff --git a/actor/manager/container_test.go b/actor/manager/container_test.go
index a31a4f21..57ea682f 100644
--- a/actor/manager/container_test.go
+++ b/actor/manager/container_test.go
@@ -16,9 +16,9 @@ package manager
 import (
 	"testing"
 
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 
 	actorErr "github.com/dapr/go-sdk/actor/error"
 	actorMock "github.com/dapr/go-sdk/actor/mock"
diff --git a/actor/mock/mock_codec.go b/actor/mock/mock_codec.go
index b0dec5c4..079c991c 100644
--- a/actor/mock/mock_codec.go
+++ b/actor/mock/mock_codec.go
@@ -1,13 +1,18 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/dapr/go-sdk/actor/codec (interfaces: Codec)
+// Source: ./actor/codec/codec.go
+//
+// Generated by this command:
+//
+//	mockgen -source ./actor/codec/codec.go -destination ./actor/mock/mock_codec.go -package mock
+//
 
-// Package actor is a generated GoMock package.
+// Package mock is a generated GoMock package.
 package mock
 
 import (
 	reflect "reflect"
 
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockCodec is a mock of Codec interface.
@@ -34,7 +39,7 @@ func (m *MockCodec) EXPECT() *MockCodecMockRecorder {
 }
 
 // Marshal mocks base method.
-func (m *MockCodec) Marshal(arg0 interface{}) ([]byte, error) {
+func (m *MockCodec) Marshal(arg0 any) ([]byte, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Marshal", arg0)
 	ret0, _ := ret[0].([]byte)
@@ -43,13 +48,13 @@ func (m *MockCodec) Marshal(arg0 interface{}) ([]byte, error) {
 }
 
 // Marshal indicates an expected call of Marshal.
-func (mr *MockCodecMockRecorder) Marshal(arg0 interface{}) *gomock.Call {
+func (mr *MockCodecMockRecorder) Marshal(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Marshal", reflect.TypeOf((*MockCodec)(nil).Marshal), arg0)
 }
 
 // Unmarshal mocks base method.
-func (m *MockCodec) Unmarshal(arg0 []byte, arg1 interface{}) error {
+func (m *MockCodec) Unmarshal(arg0 []byte, arg1 any) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Unmarshal", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -57,7 +62,7 @@ func (m *MockCodec) Unmarshal(arg0 []byte, arg1 interface{}) error {
 }
 
 // Unmarshal indicates an expected call of Unmarshal.
-func (mr *MockCodecMockRecorder) Unmarshal(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCodecMockRecorder) Unmarshal(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unmarshal", reflect.TypeOf((*MockCodec)(nil).Unmarshal), arg0, arg1)
 }
diff --git a/actor/mock/mock_container.go b/actor/mock/mock_container.go
index ee68cade..04efa363 100644
--- a/actor/mock/mock_container.go
+++ b/actor/mock/mock_container.go
@@ -1,5 +1,10 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: ../manager/container.go
+// Source: ./actor/manager/container.go
+//
+// Generated by this command:
+//
+//	mockgen -source ./actor/manager/container.go -destination ./actor/mock/mock_container.go -package mock
+//
 
 // Package mock is a generated GoMock package.
 package mock
@@ -10,7 +15,7 @@ import (
 
 	actor "github.com/dapr/go-sdk/actor"
 	error "github.com/dapr/go-sdk/actor/error"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockActorContainer is a mock of ActorContainer interface.
@@ -60,7 +65,7 @@ func (m *MockActorContainer) Invoke(methodName string, param []byte) ([]reflect.
 }
 
 // Invoke indicates an expected call of Invoke.
-func (mr *MockActorContainerMockRecorder) Invoke(methodName, param interface{}) *gomock.Call {
+func (mr *MockActorContainerMockRecorder) Invoke(methodName, param any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Invoke", reflect.TypeOf((*MockActorContainer)(nil).Invoke), methodName, param)
 }
@@ -112,7 +117,7 @@ func (m *MockActorContainerContext) Invoke(ctx context.Context, methodName strin
 }
 
 // Invoke indicates an expected call of Invoke.
-func (mr *MockActorContainerContextMockRecorder) Invoke(ctx, methodName, param interface{}) *gomock.Call {
+func (mr *MockActorContainerContextMockRecorder) Invoke(ctx, methodName, param any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Invoke", reflect.TypeOf((*MockActorContainerContext)(nil).Invoke), ctx, methodName, param)
 }
diff --git a/actor/mock/mock_manager.go b/actor/mock/mock_manager.go
index 9b2ee722..1f8bad0d 100644
--- a/actor/mock/mock_manager.go
+++ b/actor/mock/mock_manager.go
@@ -1,5 +1,10 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: ../manager/manager.go
+// Source: ./actor/manager/manager.go
+//
+// Generated by this command:
+//
+//	mockgen -source ./actor/manager/manager.go -destination ./actor/mock/mock_manager.go -package mock
+//
 
 // Package mock is a generated GoMock package.
 package mock
@@ -10,7 +15,7 @@ import (
 
 	actor "github.com/dapr/go-sdk/actor"
 	error "github.com/dapr/go-sdk/actor/error"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockActorManager is a mock of ActorManager interface.
@@ -45,7 +50,7 @@ func (m *MockActorManager) DeactivateActor(actorID string) error.ActorErr {
 }
 
 // DeactivateActor indicates an expected call of DeactivateActor.
-func (mr *MockActorManagerMockRecorder) DeactivateActor(actorID interface{}) *gomock.Call {
+func (mr *MockActorManagerMockRecorder) DeactivateActor(actorID any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateActor", reflect.TypeOf((*MockActorManager)(nil).DeactivateActor), actorID)
 }
@@ -60,7 +65,7 @@ func (m *MockActorManager) InvokeMethod(actorID, methodName string, request []by
 }
 
 // InvokeMethod indicates an expected call of InvokeMethod.
-func (mr *MockActorManagerMockRecorder) InvokeMethod(actorID, methodName, request interface{}) *gomock.Call {
+func (mr *MockActorManagerMockRecorder) InvokeMethod(actorID, methodName, request any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeMethod", reflect.TypeOf((*MockActorManager)(nil).InvokeMethod), actorID, methodName, request)
 }
@@ -74,7 +79,7 @@ func (m *MockActorManager) InvokeReminder(actorID, reminderName string, params [
 }
 
 // InvokeReminder indicates an expected call of InvokeReminder.
-func (mr *MockActorManagerMockRecorder) InvokeReminder(actorID, reminderName, params interface{}) *gomock.Call {
+func (mr *MockActorManagerMockRecorder) InvokeReminder(actorID, reminderName, params any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeReminder", reflect.TypeOf((*MockActorManager)(nil).InvokeReminder), actorID, reminderName, params)
 }
@@ -88,7 +93,7 @@ func (m *MockActorManager) InvokeTimer(actorID, timerName string, params []byte)
 }
 
 // InvokeTimer indicates an expected call of InvokeTimer.
-func (mr *MockActorManagerMockRecorder) InvokeTimer(actorID, timerName, params interface{}) *gomock.Call {
+func (mr *MockActorManagerMockRecorder) InvokeTimer(actorID, timerName, params any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeTimer", reflect.TypeOf((*MockActorManager)(nil).InvokeTimer), actorID, timerName, params)
 }
@@ -100,7 +105,7 @@ func (m *MockActorManager) RegisterActorImplFactory(f actor.Factory) {
 }
 
 // RegisterActorImplFactory indicates an expected call of RegisterActorImplFactory.
-func (mr *MockActorManagerMockRecorder) RegisterActorImplFactory(f interface{}) *gomock.Call {
+func (mr *MockActorManagerMockRecorder) RegisterActorImplFactory(f any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActorImplFactory", reflect.TypeOf((*MockActorManager)(nil).RegisterActorImplFactory), f)
 }
@@ -137,7 +142,7 @@ func (m *MockActorManagerContext) DeactivateActor(ctx context.Context, actorID s
 }
 
 // DeactivateActor indicates an expected call of DeactivateActor.
-func (mr *MockActorManagerContextMockRecorder) DeactivateActor(ctx, actorID interface{}) *gomock.Call {
+func (mr *MockActorManagerContextMockRecorder) DeactivateActor(ctx, actorID any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateActor", reflect.TypeOf((*MockActorManagerContext)(nil).DeactivateActor), ctx, actorID)
 }
@@ -152,7 +157,7 @@ func (m *MockActorManagerContext) InvokeMethod(ctx context.Context, actorID, met
 }
 
 // InvokeMethod indicates an expected call of InvokeMethod.
-func (mr *MockActorManagerContextMockRecorder) InvokeMethod(ctx, actorID, methodName, request interface{}) *gomock.Call {
+func (mr *MockActorManagerContextMockRecorder) InvokeMethod(ctx, actorID, methodName, request any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeMethod", reflect.TypeOf((*MockActorManagerContext)(nil).InvokeMethod), ctx, actorID, methodName, request)
 }
@@ -166,7 +171,7 @@ func (m *MockActorManagerContext) InvokeReminder(ctx context.Context, actorID, r
 }
 
 // InvokeReminder indicates an expected call of InvokeReminder.
-func (mr *MockActorManagerContextMockRecorder) InvokeReminder(ctx, actorID, reminderName, params interface{}) *gomock.Call {
+func (mr *MockActorManagerContextMockRecorder) InvokeReminder(ctx, actorID, reminderName, params any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeReminder", reflect.TypeOf((*MockActorManagerContext)(nil).InvokeReminder), ctx, actorID, reminderName, params)
 }
@@ -180,7 +185,7 @@ func (m *MockActorManagerContext) InvokeTimer(ctx context.Context, actorID, time
 }
 
 // InvokeTimer indicates an expected call of InvokeTimer.
-func (mr *MockActorManagerContextMockRecorder) InvokeTimer(ctx, actorID, timerName, params interface{}) *gomock.Call {
+func (mr *MockActorManagerContextMockRecorder) InvokeTimer(ctx, actorID, timerName, params any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeTimer", reflect.TypeOf((*MockActorManagerContext)(nil).InvokeTimer), ctx, actorID, timerName, params)
 }
@@ -192,7 +197,7 @@ func (m *MockActorManagerContext) RegisterActorImplFactory(f actor.FactoryContex
 }
 
 // RegisterActorImplFactory indicates an expected call of RegisterActorImplFactory.
-func (mr *MockActorManagerContextMockRecorder) RegisterActorImplFactory(f interface{}) *gomock.Call {
+func (mr *MockActorManagerContextMockRecorder) RegisterActorImplFactory(f any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActorImplFactory", reflect.TypeOf((*MockActorManagerContext)(nil).RegisterActorImplFactory), f)
 }
diff --git a/actor/mock/mock_server.go b/actor/mock/mock_server.go
index 882dca9e..4ca3ac79 100644
--- a/actor/mock/mock_server.go
+++ b/actor/mock/mock_server.go
@@ -1,5 +1,10 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: ../actor.go
+// Source: ./actor/actor.go
+//
+// Generated by this command:
+//
+//	mockgen -source ./actor/actor.go -destination ./actor/mock/mock_server.go -package mock
+//
 
 // Package mock is a generated GoMock package.
 package mock
@@ -7,9 +12,10 @@ package mock
 import (
 	context "context"
 	reflect "reflect"
+	time "time"
 
 	actor "github.com/dapr/go-sdk/actor"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockClient is a mock of Client interface.
@@ -121,7 +127,7 @@ func (m *MockServer) SetID(arg0 string) {
 }
 
 // SetID indicates an expected call of SetID.
-func (mr *MockServerMockRecorder) SetID(arg0 interface{}) *gomock.Call {
+func (mr *MockServerMockRecorder) SetID(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetID", reflect.TypeOf((*MockServer)(nil).SetID), arg0)
 }
@@ -133,7 +139,7 @@ func (m *MockServer) SetStateManager(arg0 actor.StateManager) {
 }
 
 // SetStateManager indicates an expected call of SetStateManager.
-func (mr *MockServerMockRecorder) SetStateManager(arg0 interface{}) *gomock.Call {
+func (mr *MockServerMockRecorder) SetStateManager(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStateManager", reflect.TypeOf((*MockServer)(nil).SetStateManager), arg0)
 }
@@ -212,7 +218,7 @@ func (m *MockServerContext) SaveState(arg0 context.Context) error {
 }
 
 // SaveState indicates an expected call of SaveState.
-func (mr *MockServerContextMockRecorder) SaveState(arg0 interface{}) *gomock.Call {
+func (mr *MockServerContextMockRecorder) SaveState(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveState", reflect.TypeOf((*MockServerContext)(nil).SaveState), arg0)
 }
@@ -224,7 +230,7 @@ func (m *MockServerContext) SetID(arg0 string) {
 }
 
 // SetID indicates an expected call of SetID.
-func (mr *MockServerContextMockRecorder) SetID(arg0 interface{}) *gomock.Call {
+func (mr *MockServerContextMockRecorder) SetID(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetID", reflect.TypeOf((*MockServerContext)(nil).SetID), arg0)
 }
@@ -236,7 +242,7 @@ func (m *MockServerContext) SetStateManager(arg0 actor.StateManagerContext) {
 }
 
 // SetStateManager indicates an expected call of SetStateManager.
-func (mr *MockServerContextMockRecorder) SetStateManager(arg0 interface{}) *gomock.Call {
+func (mr *MockServerContextMockRecorder) SetStateManager(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStateManager", reflect.TypeOf((*MockServerContext)(nil).SetStateManager), arg0)
 }
@@ -298,7 +304,7 @@ func (m *MockReminderCallee) ReminderCall(arg0 string, arg1 []byte, arg2, arg3 s
 }
 
 // ReminderCall indicates an expected call of ReminderCall.
-func (mr *MockReminderCalleeMockRecorder) ReminderCall(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockReminderCalleeMockRecorder) ReminderCall(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReminderCall", reflect.TypeOf((*MockReminderCallee)(nil).ReminderCall), arg0, arg1, arg2, arg3)
 }
@@ -335,7 +341,7 @@ func (m *MockStateManager) Add(stateName string, value any) error {
 }
 
 // Add indicates an expected call of Add.
-func (mr *MockStateManagerMockRecorder) Add(stateName, value interface{}) *gomock.Call {
+func (mr *MockStateManagerMockRecorder) Add(stateName, value any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockStateManager)(nil).Add), stateName, value)
 }
@@ -350,7 +356,7 @@ func (m *MockStateManager) Contains(stateName string) (bool, error) {
 }
 
 // Contains indicates an expected call of Contains.
-func (mr *MockStateManagerMockRecorder) Contains(stateName interface{}) *gomock.Call {
+func (mr *MockStateManagerMockRecorder) Contains(stateName any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Contains", reflect.TypeOf((*MockStateManager)(nil).Contains), stateName)
 }
@@ -376,7 +382,7 @@ func (m *MockStateManager) Get(stateName string, reply any) error {
 }
 
 // Get indicates an expected call of Get.
-func (mr *MockStateManagerMockRecorder) Get(stateName, reply interface{}) *gomock.Call {
+func (mr *MockStateManagerMockRecorder) Get(stateName, reply any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStateManager)(nil).Get), stateName, reply)
 }
@@ -390,7 +396,7 @@ func (m *MockStateManager) Remove(stateName string) error {
 }
 
 // Remove indicates an expected call of Remove.
-func (mr *MockStateManagerMockRecorder) Remove(stateName interface{}) *gomock.Call {
+func (mr *MockStateManagerMockRecorder) Remove(stateName any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockStateManager)(nil).Remove), stateName)
 }
@@ -418,7 +424,7 @@ func (m *MockStateManager) Set(stateName string, value any) error {
 }
 
 // Set indicates an expected call of Set.
-func (mr *MockStateManagerMockRecorder) Set(stateName, value interface{}) *gomock.Call {
+func (mr *MockStateManagerMockRecorder) Set(stateName, value any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockStateManager)(nil).Set), stateName, value)
 }
@@ -469,7 +475,7 @@ func (m *MockStateManagerContext) Add(ctx context.Context, stateName string, val
 }
 
 // Add indicates an expected call of Add.
-func (mr *MockStateManagerContextMockRecorder) Add(ctx, stateName, value interface{}) *gomock.Call {
+func (mr *MockStateManagerContextMockRecorder) Add(ctx, stateName, value any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockStateManagerContext)(nil).Add), ctx, stateName, value)
 }
@@ -484,7 +490,7 @@ func (m *MockStateManagerContext) Contains(ctx context.Context, stateName string
 }
 
 // Contains indicates an expected call of Contains.
-func (mr *MockStateManagerContextMockRecorder) Contains(ctx, stateName interface{}) *gomock.Call {
+func (mr *MockStateManagerContextMockRecorder) Contains(ctx, stateName any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Contains", reflect.TypeOf((*MockStateManagerContext)(nil).Contains), ctx, stateName)
 }
@@ -496,7 +502,7 @@ func (m *MockStateManagerContext) Flush(ctx context.Context) {
 }
 
 // Flush indicates an expected call of Flush.
-func (mr *MockStateManagerContextMockRecorder) Flush(ctx interface{}) *gomock.Call {
+func (mr *MockStateManagerContextMockRecorder) Flush(ctx any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Flush", reflect.TypeOf((*MockStateManagerContext)(nil).Flush), ctx)
 }
@@ -510,7 +516,7 @@ func (m *MockStateManagerContext) Get(ctx context.Context, stateName string, rep
 }
 
 // Get indicates an expected call of Get.
-func (mr *MockStateManagerContextMockRecorder) Get(ctx, stateName, reply interface{}) *gomock.Call {
+func (mr *MockStateManagerContextMockRecorder) Get(ctx, stateName, reply any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStateManagerContext)(nil).Get), ctx, stateName, reply)
 }
@@ -524,7 +530,7 @@ func (m *MockStateManagerContext) Remove(ctx context.Context, stateName string)
 }
 
 // Remove indicates an expected call of Remove.
-func (mr *MockStateManagerContextMockRecorder) Remove(ctx, stateName interface{}) *gomock.Call {
+func (mr *MockStateManagerContextMockRecorder) Remove(ctx, stateName any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockStateManagerContext)(nil).Remove), ctx, stateName)
 }
@@ -538,7 +544,7 @@ func (m *MockStateManagerContext) Save(ctx context.Context) error {
 }
 
 // Save indicates an expected call of Save.
-func (mr *MockStateManagerContextMockRecorder) Save(ctx interface{}) *gomock.Call {
+func (mr *MockStateManagerContextMockRecorder) Save(ctx any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockStateManagerContext)(nil).Save), ctx)
 }
@@ -552,7 +558,21 @@ func (m *MockStateManagerContext) Set(ctx context.Context, stateName string, val
 }
 
 // Set indicates an expected call of Set.
-func (mr *MockStateManagerContextMockRecorder) Set(ctx, stateName, value interface{}) *gomock.Call {
+func (mr *MockStateManagerContextMockRecorder) Set(ctx, stateName, value any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockStateManagerContext)(nil).Set), ctx, stateName, value)
 }
+
+// SetWithTTL mocks base method.
+func (m *MockStateManagerContext) SetWithTTL(ctx context.Context, stateName string, value any, ttl time.Duration) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetWithTTL", ctx, stateName, value, ttl)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SetWithTTL indicates an expected call of SetWithTTL.
+func (mr *MockStateManagerContextMockRecorder) SetWithTTL(ctx, stateName, value, ttl any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWithTTL", reflect.TypeOf((*MockStateManagerContext)(nil).SetWithTTL), ctx, stateName, value, ttl)
+}
diff --git a/actor/mock_client/mock_client.go b/actor/mock_client/mock_client.go
new file mode 100644
index 00000000..3331f52d
--- /dev/null
+++ b/actor/mock_client/mock_client.go
@@ -0,0 +1,942 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: ./client/client.go
+//
+// Generated by this command:
+//
+//	mockgen -source ./client/client.go -destination ./actor/mock_client/mock_client.go -package mock_client
+//
+
+// Package mock_client is a generated GoMock package.
+package mock_client
+
+import (
+	context "context"
+	io "io"
+	reflect "reflect"
+	time "time"
+
+	runtime "github.com/dapr/dapr/pkg/proto/runtime/v1"
+	actor "github.com/dapr/go-sdk/actor"
+	config "github.com/dapr/go-sdk/actor/config"
+	client "github.com/dapr/go-sdk/client"
+	gomock "go.uber.org/mock/gomock"
+	grpc "google.golang.org/grpc"
+)
+
+// MockClient is a mock of Client interface.
+type MockClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockClientMockRecorder
+}
+
+// MockClientMockRecorder is the mock recorder for MockClient.
+type MockClientMockRecorder struct {
+	mock *MockClient
+}
+
+// NewMockClient creates a new mock instance.
+func NewMockClient(ctrl *gomock.Controller) *MockClient {
+	mock := &MockClient{ctrl: ctrl}
+	mock.recorder = &MockClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockClient) EXPECT() *MockClientMockRecorder {
+	return m.recorder
+}
+
+// Close mocks base method.
+func (m *MockClient) Close() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Close")
+}
+
+// Close indicates an expected call of Close.
+func (mr *MockClientMockRecorder) Close() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClient)(nil).Close))
+}
+
+// Decrypt mocks base method.
+func (m *MockClient) Decrypt(ctx context.Context, in io.Reader, opts client.DecryptOptions) (io.Reader, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Decrypt", ctx, in, opts)
+	ret0, _ := ret[0].(io.Reader)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Decrypt indicates an expected call of Decrypt.
+func (mr *MockClientMockRecorder) Decrypt(ctx, in, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decrypt", reflect.TypeOf((*MockClient)(nil).Decrypt), ctx, in, opts)
+}
+
+// DeleteBulkState mocks base method.
+func (m *MockClient) DeleteBulkState(ctx context.Context, storeName string, keys []string, meta map[string]string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteBulkState", ctx, storeName, keys, meta)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteBulkState indicates an expected call of DeleteBulkState.
+func (mr *MockClientMockRecorder) DeleteBulkState(ctx, storeName, keys, meta any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBulkState", reflect.TypeOf((*MockClient)(nil).DeleteBulkState), ctx, storeName, keys, meta)
+}
+
+// DeleteBulkStateItems mocks base method.
+func (m *MockClient) DeleteBulkStateItems(ctx context.Context, storeName string, items []*client.DeleteStateItem) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteBulkStateItems", ctx, storeName, items)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteBulkStateItems indicates an expected call of DeleteBulkStateItems.
+func (mr *MockClientMockRecorder) DeleteBulkStateItems(ctx, storeName, items any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBulkStateItems", reflect.TypeOf((*MockClient)(nil).DeleteBulkStateItems), ctx, storeName, items)
+}
+
+// DeleteJobAlpha1 mocks base method.
+func (m *MockClient) DeleteJobAlpha1(ctx context.Context, name string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteJobAlpha1", ctx, name)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteJobAlpha1 indicates an expected call of DeleteJobAlpha1.
+func (mr *MockClientMockRecorder) DeleteJobAlpha1(ctx, name any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteJobAlpha1", reflect.TypeOf((*MockClient)(nil).DeleteJobAlpha1), ctx, name)
+}
+
+// DeleteState mocks base method.
+func (m *MockClient) DeleteState(ctx context.Context, storeName, key string, meta map[string]string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteState", ctx, storeName, key, meta)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteState indicates an expected call of DeleteState.
+func (mr *MockClientMockRecorder) DeleteState(ctx, storeName, key, meta any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteState", reflect.TypeOf((*MockClient)(nil).DeleteState), ctx, storeName, key, meta)
+}
+
+// DeleteStateWithETag mocks base method.
+func (m *MockClient) DeleteStateWithETag(ctx context.Context, storeName, key string, etag *client.ETag, meta map[string]string, opts *client.StateOptions) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteStateWithETag", ctx, storeName, key, etag, meta, opts)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteStateWithETag indicates an expected call of DeleteStateWithETag.
+func (mr *MockClientMockRecorder) DeleteStateWithETag(ctx, storeName, key, etag, meta, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStateWithETag", reflect.TypeOf((*MockClient)(nil).DeleteStateWithETag), ctx, storeName, key, etag, meta, opts)
+}
+
+// Encrypt mocks base method.
+func (m *MockClient) Encrypt(ctx context.Context, in io.Reader, opts client.EncryptOptions) (io.Reader, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Encrypt", ctx, in, opts)
+	ret0, _ := ret[0].(io.Reader)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Encrypt indicates an expected call of Encrypt.
+func (mr *MockClientMockRecorder) Encrypt(ctx, in, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Encrypt", reflect.TypeOf((*MockClient)(nil).Encrypt), ctx, in, opts)
+}
+
+// ExecuteStateTransaction mocks base method.
+func (m *MockClient) ExecuteStateTransaction(ctx context.Context, storeName string, meta map[string]string, ops []*client.StateOperation) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExecuteStateTransaction", ctx, storeName, meta, ops)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ExecuteStateTransaction indicates an expected call of ExecuteStateTransaction.
+func (mr *MockClientMockRecorder) ExecuteStateTransaction(ctx, storeName, meta, ops any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteStateTransaction", reflect.TypeOf((*MockClient)(nil).ExecuteStateTransaction), ctx, storeName, meta, ops)
+}
+
+// GetActorState mocks base method.
+func (m *MockClient) GetActorState(ctx context.Context, req *client.GetActorStateRequest) (*client.GetActorStateResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetActorState", ctx, req)
+	ret0, _ := ret[0].(*client.GetActorStateResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetActorState indicates an expected call of GetActorState.
+func (mr *MockClientMockRecorder) GetActorState(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActorState", reflect.TypeOf((*MockClient)(nil).GetActorState), ctx, req)
+}
+
+// GetBulkSecret mocks base method.
+func (m *MockClient) GetBulkSecret(ctx context.Context, storeName string, meta map[string]string) (map[string]map[string]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBulkSecret", ctx, storeName, meta)
+	ret0, _ := ret[0].(map[string]map[string]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBulkSecret indicates an expected call of GetBulkSecret.
+func (mr *MockClientMockRecorder) GetBulkSecret(ctx, storeName, meta any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBulkSecret", reflect.TypeOf((*MockClient)(nil).GetBulkSecret), ctx, storeName, meta)
+}
+
+// GetBulkState mocks base method.
+func (m *MockClient) GetBulkState(ctx context.Context, storeName string, keys []string, meta map[string]string, parallelism int32) ([]*client.BulkStateItem, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBulkState", ctx, storeName, keys, meta, parallelism)
+	ret0, _ := ret[0].([]*client.BulkStateItem)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBulkState indicates an expected call of GetBulkState.
+func (mr *MockClientMockRecorder) GetBulkState(ctx, storeName, keys, meta, parallelism any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBulkState", reflect.TypeOf((*MockClient)(nil).GetBulkState), ctx, storeName, keys, meta, parallelism)
+}
+
+// GetConfigurationItem mocks base method.
+func (m *MockClient) GetConfigurationItem(ctx context.Context, storeName, key string, opts ...client.ConfigurationOpt) (*client.ConfigurationItem, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, storeName, key}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetConfigurationItem", varargs...)
+	ret0, _ := ret[0].(*client.ConfigurationItem)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetConfigurationItem indicates an expected call of GetConfigurationItem.
+func (mr *MockClientMockRecorder) GetConfigurationItem(ctx, storeName, key any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, storeName, key}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigurationItem", reflect.TypeOf((*MockClient)(nil).GetConfigurationItem), varargs...)
+}
+
+// GetConfigurationItems mocks base method.
+func (m *MockClient) GetConfigurationItems(ctx context.Context, storeName string, keys []string, opts ...client.ConfigurationOpt) (map[string]*client.ConfigurationItem, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, storeName, keys}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetConfigurationItems", varargs...)
+	ret0, _ := ret[0].(map[string]*client.ConfigurationItem)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetConfigurationItems indicates an expected call of GetConfigurationItems.
+func (mr *MockClientMockRecorder) GetConfigurationItems(ctx, storeName, keys any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, storeName, keys}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigurationItems", reflect.TypeOf((*MockClient)(nil).GetConfigurationItems), varargs...)
+}
+
+// GetJobAlpha1 mocks base method.
+func (m *MockClient) GetJobAlpha1(ctx context.Context, name string) (*client.Job, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetJobAlpha1", ctx, name)
+	ret0, _ := ret[0].(*client.Job)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetJobAlpha1 indicates an expected call of GetJobAlpha1.
+func (mr *MockClientMockRecorder) GetJobAlpha1(ctx, name any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJobAlpha1", reflect.TypeOf((*MockClient)(nil).GetJobAlpha1), ctx, name)
+}
+
+// GetMetadata mocks base method.
+func (m *MockClient) GetMetadata(ctx context.Context) (*client.GetMetadataResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetMetadata", ctx)
+	ret0, _ := ret[0].(*client.GetMetadataResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetMetadata indicates an expected call of GetMetadata.
+func (mr *MockClientMockRecorder) GetMetadata(ctx any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockClient)(nil).GetMetadata), ctx)
+}
+
+// GetSecret mocks base method.
+func (m *MockClient) GetSecret(ctx context.Context, storeName, key string, meta map[string]string) (map[string]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSecret", ctx, storeName, key, meta)
+	ret0, _ := ret[0].(map[string]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSecret indicates an expected call of GetSecret.
+func (mr *MockClientMockRecorder) GetSecret(ctx, storeName, key, meta any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecret", reflect.TypeOf((*MockClient)(nil).GetSecret), ctx, storeName, key, meta)
+}
+
+// GetState mocks base method.
+func (m *MockClient) GetState(ctx context.Context, storeName, key string, meta map[string]string) (*client.StateItem, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetState", ctx, storeName, key, meta)
+	ret0, _ := ret[0].(*client.StateItem)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetState indicates an expected call of GetState.
+func (mr *MockClientMockRecorder) GetState(ctx, storeName, key, meta any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetState", reflect.TypeOf((*MockClient)(nil).GetState), ctx, storeName, key, meta)
+}
+
+// GetStateWithConsistency mocks base method.
+func (m *MockClient) GetStateWithConsistency(ctx context.Context, storeName, key string, meta map[string]string, sc client.StateConsistency) (*client.StateItem, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStateWithConsistency", ctx, storeName, key, meta, sc)
+	ret0, _ := ret[0].(*client.StateItem)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStateWithConsistency indicates an expected call of GetStateWithConsistency.
+func (mr *MockClientMockRecorder) GetStateWithConsistency(ctx, storeName, key, meta, sc any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStateWithConsistency", reflect.TypeOf((*MockClient)(nil).GetStateWithConsistency), ctx, storeName, key, meta, sc)
+}
+
+// GetWorkflowBeta1 mocks base method.
+func (m *MockClient) GetWorkflowBeta1(ctx context.Context, req *client.GetWorkflowRequest) (*client.GetWorkflowResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetWorkflowBeta1", ctx, req)
+	ret0, _ := ret[0].(*client.GetWorkflowResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetWorkflowBeta1 indicates an expected call of GetWorkflowBeta1.
+func (mr *MockClientMockRecorder) GetWorkflowBeta1(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).GetWorkflowBeta1), ctx, req)
+}
+
+// GrpcClient mocks base method.
+func (m *MockClient) GrpcClient() runtime.DaprClient {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GrpcClient")
+	ret0, _ := ret[0].(runtime.DaprClient)
+	return ret0
+}
+
+// GrpcClient indicates an expected call of GrpcClient.
+func (mr *MockClientMockRecorder) GrpcClient() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrpcClient", reflect.TypeOf((*MockClient)(nil).GrpcClient))
+}
+
+// GrpcClientConn mocks base method.
+func (m *MockClient) GrpcClientConn() *grpc.ClientConn {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GrpcClientConn")
+	ret0, _ := ret[0].(*grpc.ClientConn)
+	return ret0
+}
+
+// GrpcClientConn indicates an expected call of GrpcClientConn.
+func (mr *MockClientMockRecorder) GrpcClientConn() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrpcClientConn", reflect.TypeOf((*MockClient)(nil).GrpcClientConn))
+}
+
+// ImplActorClientStub mocks base method.
+func (m *MockClient) ImplActorClientStub(actorClientStub actor.Client, opt ...config.Option) {
+	m.ctrl.T.Helper()
+	varargs := []any{actorClientStub}
+	for _, a := range opt {
+		varargs = append(varargs, a)
+	}
+	m.ctrl.Call(m, "ImplActorClientStub", varargs...)
+}
+
+// ImplActorClientStub indicates an expected call of ImplActorClientStub.
+func (mr *MockClientMockRecorder) ImplActorClientStub(actorClientStub any, opt ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{actorClientStub}, opt...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImplActorClientStub", reflect.TypeOf((*MockClient)(nil).ImplActorClientStub), varargs...)
+}
+
+// InvokeActor mocks base method.
+func (m *MockClient) InvokeActor(ctx context.Context, req *client.InvokeActorRequest) (*client.InvokeActorResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InvokeActor", ctx, req)
+	ret0, _ := ret[0].(*client.InvokeActorResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// InvokeActor indicates an expected call of InvokeActor.
+func (mr *MockClientMockRecorder) InvokeActor(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeActor", reflect.TypeOf((*MockClient)(nil).InvokeActor), ctx, req)
+}
+
+// InvokeBinding mocks base method.
+func (m *MockClient) InvokeBinding(ctx context.Context, in *client.InvokeBindingRequest) (*client.BindingEvent, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InvokeBinding", ctx, in)
+	ret0, _ := ret[0].(*client.BindingEvent)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// InvokeBinding indicates an expected call of InvokeBinding.
+func (mr *MockClientMockRecorder) InvokeBinding(ctx, in any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeBinding", reflect.TypeOf((*MockClient)(nil).InvokeBinding), ctx, in)
+}
+
+// InvokeMethod mocks base method.
+func (m *MockClient) InvokeMethod(ctx context.Context, appID, methodName, verb string) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InvokeMethod", ctx, appID, methodName, verb)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// InvokeMethod indicates an expected call of InvokeMethod.
+func (mr *MockClientMockRecorder) InvokeMethod(ctx, appID, methodName, verb any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeMethod", reflect.TypeOf((*MockClient)(nil).InvokeMethod), ctx, appID, methodName, verb)
+}
+
+// InvokeMethodWithContent mocks base method.
+func (m *MockClient) InvokeMethodWithContent(ctx context.Context, appID, methodName, verb string, content *client.DataContent) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InvokeMethodWithContent", ctx, appID, methodName, verb, content)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// InvokeMethodWithContent indicates an expected call of InvokeMethodWithContent.
+func (mr *MockClientMockRecorder) InvokeMethodWithContent(ctx, appID, methodName, verb, content any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeMethodWithContent", reflect.TypeOf((*MockClient)(nil).InvokeMethodWithContent), ctx, appID, methodName, verb, content)
+}
+
+// InvokeMethodWithCustomContent mocks base method.
+func (m *MockClient) InvokeMethodWithCustomContent(ctx context.Context, appID, methodName, verb, contentType string, content any) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InvokeMethodWithCustomContent", ctx, appID, methodName, verb, contentType, content)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// InvokeMethodWithCustomContent indicates an expected call of InvokeMethodWithCustomContent.
+func (mr *MockClientMockRecorder) InvokeMethodWithCustomContent(ctx, appID, methodName, verb, contentType, content any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeMethodWithCustomContent", reflect.TypeOf((*MockClient)(nil).InvokeMethodWithCustomContent), ctx, appID, methodName, verb, contentType, content)
+}
+
+// InvokeOutputBinding mocks base method.
+func (m *MockClient) InvokeOutputBinding(ctx context.Context, in *client.InvokeBindingRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InvokeOutputBinding", ctx, in)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// InvokeOutputBinding indicates an expected call of InvokeOutputBinding.
+func (mr *MockClientMockRecorder) InvokeOutputBinding(ctx, in any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeOutputBinding", reflect.TypeOf((*MockClient)(nil).InvokeOutputBinding), ctx, in)
+}
+
+// PauseWorkflowBeta1 mocks base method.
+func (m *MockClient) PauseWorkflowBeta1(ctx context.Context, req *client.PauseWorkflowRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PauseWorkflowBeta1", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// PauseWorkflowBeta1 indicates an expected call of PauseWorkflowBeta1.
+func (mr *MockClientMockRecorder) PauseWorkflowBeta1(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).PauseWorkflowBeta1), ctx, req)
+}
+
+// PublishEvent mocks base method.
+func (m *MockClient) PublishEvent(ctx context.Context, pubsubName, topicName string, data any, opts ...client.PublishEventOption) error {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, pubsubName, topicName, data}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PublishEvent", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// PublishEvent indicates an expected call of PublishEvent.
+func (mr *MockClientMockRecorder) PublishEvent(ctx, pubsubName, topicName, data any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, pubsubName, topicName, data}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishEvent", reflect.TypeOf((*MockClient)(nil).PublishEvent), varargs...)
+}
+
+// PublishEventfromCustomContent mocks base method.
+func (m *MockClient) PublishEventfromCustomContent(ctx context.Context, pubsubName, topicName string, data any) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PublishEventfromCustomContent", ctx, pubsubName, topicName, data)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// PublishEventfromCustomContent indicates an expected call of PublishEventfromCustomContent.
+func (mr *MockClientMockRecorder) PublishEventfromCustomContent(ctx, pubsubName, topicName, data any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishEventfromCustomContent", reflect.TypeOf((*MockClient)(nil).PublishEventfromCustomContent), ctx, pubsubName, topicName, data)
+}
+
+// PublishEvents mocks base method.
+func (m *MockClient) PublishEvents(ctx context.Context, pubsubName, topicName string, events []any, opts ...client.PublishEventsOption) client.PublishEventsResponse {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, pubsubName, topicName, events}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PublishEvents", varargs...)
+	ret0, _ := ret[0].(client.PublishEventsResponse)
+	return ret0
+}
+
+// PublishEvents indicates an expected call of PublishEvents.
+func (mr *MockClientMockRecorder) PublishEvents(ctx, pubsubName, topicName, events any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, pubsubName, topicName, events}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishEvents", reflect.TypeOf((*MockClient)(nil).PublishEvents), varargs...)
+}
+
+// PurgeWorkflowBeta1 mocks base method.
+func (m *MockClient) PurgeWorkflowBeta1(ctx context.Context, req *client.PurgeWorkflowRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PurgeWorkflowBeta1", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// PurgeWorkflowBeta1 indicates an expected call of PurgeWorkflowBeta1.
+func (mr *MockClientMockRecorder) PurgeWorkflowBeta1(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).PurgeWorkflowBeta1), ctx, req)
+}
+
+// QueryStateAlpha1 mocks base method.
+func (m *MockClient) QueryStateAlpha1(ctx context.Context, storeName, query string, meta map[string]string) (*client.QueryResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "QueryStateAlpha1", ctx, storeName, query, meta)
+	ret0, _ := ret[0].(*client.QueryResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// QueryStateAlpha1 indicates an expected call of QueryStateAlpha1.
+func (mr *MockClientMockRecorder) QueryStateAlpha1(ctx, storeName, query, meta any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryStateAlpha1", reflect.TypeOf((*MockClient)(nil).QueryStateAlpha1), ctx, storeName, query, meta)
+}
+
+// RaiseEventWorkflowBeta1 mocks base method.
+func (m *MockClient) RaiseEventWorkflowBeta1(ctx context.Context, req *client.RaiseEventWorkflowRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RaiseEventWorkflowBeta1", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RaiseEventWorkflowBeta1 indicates an expected call of RaiseEventWorkflowBeta1.
+func (mr *MockClientMockRecorder) RaiseEventWorkflowBeta1(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RaiseEventWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).RaiseEventWorkflowBeta1), ctx, req)
+}
+
+// RegisterActorReminder mocks base method.
+func (m *MockClient) RegisterActorReminder(ctx context.Context, req *client.RegisterActorReminderRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RegisterActorReminder", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RegisterActorReminder indicates an expected call of RegisterActorReminder.
+func (mr *MockClientMockRecorder) RegisterActorReminder(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActorReminder", reflect.TypeOf((*MockClient)(nil).RegisterActorReminder), ctx, req)
+}
+
+// RegisterActorTimer mocks base method.
+func (m *MockClient) RegisterActorTimer(ctx context.Context, req *client.RegisterActorTimerRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RegisterActorTimer", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RegisterActorTimer indicates an expected call of RegisterActorTimer.
+func (mr *MockClientMockRecorder) RegisterActorTimer(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActorTimer", reflect.TypeOf((*MockClient)(nil).RegisterActorTimer), ctx, req)
+}
+
+// ResumeWorkflowBeta1 mocks base method.
+func (m *MockClient) ResumeWorkflowBeta1(ctx context.Context, req *client.ResumeWorkflowRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResumeWorkflowBeta1", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ResumeWorkflowBeta1 indicates an expected call of ResumeWorkflowBeta1.
+func (mr *MockClientMockRecorder) ResumeWorkflowBeta1(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).ResumeWorkflowBeta1), ctx, req)
+}
+
+// SaveBulkState mocks base method.
+func (m *MockClient) SaveBulkState(ctx context.Context, storeName string, items ...*client.SetStateItem) error {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, storeName}
+	for _, a := range items {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SaveBulkState", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SaveBulkState indicates an expected call of SaveBulkState.
+func (mr *MockClientMockRecorder) SaveBulkState(ctx, storeName any, items ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, storeName}, items...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveBulkState", reflect.TypeOf((*MockClient)(nil).SaveBulkState), varargs...)
+}
+
+// SaveState mocks base method.
+func (m *MockClient) SaveState(ctx context.Context, storeName, key string, data []byte, meta map[string]string, so ...client.StateOption) error {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, storeName, key, data, meta}
+	for _, a := range so {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SaveState", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SaveState indicates an expected call of SaveState.
+func (mr *MockClientMockRecorder) SaveState(ctx, storeName, key, data, meta any, so ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, storeName, key, data, meta}, so...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveState", reflect.TypeOf((*MockClient)(nil).SaveState), varargs...)
+}
+
+// SaveStateTransactionally mocks base method.
+func (m *MockClient) SaveStateTransactionally(ctx context.Context, actorType, actorID string, operations []*client.ActorStateOperation) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SaveStateTransactionally", ctx, actorType, actorID, operations)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SaveStateTransactionally indicates an expected call of SaveStateTransactionally.
+func (mr *MockClientMockRecorder) SaveStateTransactionally(ctx, actorType, actorID, operations any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveStateTransactionally", reflect.TypeOf((*MockClient)(nil).SaveStateTransactionally), ctx, actorType, actorID, operations)
+}
+
+// SaveStateWithETag mocks base method.
+func (m *MockClient) SaveStateWithETag(ctx context.Context, storeName, key string, data []byte, etag string, meta map[string]string, so ...client.StateOption) error {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, storeName, key, data, etag, meta}
+	for _, a := range so {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SaveStateWithETag", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SaveStateWithETag indicates an expected call of SaveStateWithETag.
+func (mr *MockClientMockRecorder) SaveStateWithETag(ctx, storeName, key, data, etag, meta any, so ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, storeName, key, data, etag, meta}, so...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveStateWithETag", reflect.TypeOf((*MockClient)(nil).SaveStateWithETag), varargs...)
+}
+
+// ScheduleJobAlpha1 mocks base method.
+func (m *MockClient) ScheduleJobAlpha1(ctx context.Context, req *client.Job) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ScheduleJobAlpha1", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ScheduleJobAlpha1 indicates an expected call of ScheduleJobAlpha1.
+func (mr *MockClientMockRecorder) ScheduleJobAlpha1(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleJobAlpha1", reflect.TypeOf((*MockClient)(nil).ScheduleJobAlpha1), ctx, req)
+}
+
+// SetMetadata mocks base method.
+func (m *MockClient) SetMetadata(ctx context.Context, key, value string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetMetadata", ctx, key, value)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SetMetadata indicates an expected call of SetMetadata.
+func (mr *MockClientMockRecorder) SetMetadata(ctx, key, value any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMetadata", reflect.TypeOf((*MockClient)(nil).SetMetadata), ctx, key, value)
+}
+
+// Shutdown mocks base method.
+func (m *MockClient) Shutdown(ctx context.Context) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Shutdown", ctx)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Shutdown indicates an expected call of Shutdown.
+func (mr *MockClientMockRecorder) Shutdown(ctx any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockClient)(nil).Shutdown), ctx)
+}
+
+// StartWorkflowBeta1 mocks base method.
+func (m *MockClient) StartWorkflowBeta1(ctx context.Context, req *client.StartWorkflowRequest) (*client.StartWorkflowResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StartWorkflowBeta1", ctx, req)
+	ret0, _ := ret[0].(*client.StartWorkflowResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StartWorkflowBeta1 indicates an expected call of StartWorkflowBeta1.
+func (mr *MockClientMockRecorder) StartWorkflowBeta1(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).StartWorkflowBeta1), ctx, req)
+}
+
+// Subscribe mocks base method.
+func (m *MockClient) Subscribe(ctx context.Context, opts client.SubscriptionOptions) (*client.Subscription, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Subscribe", ctx, opts)
+	ret0, _ := ret[0].(*client.Subscription)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Subscribe indicates an expected call of Subscribe.
+func (mr *MockClientMockRecorder) Subscribe(ctx, opts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockClient)(nil).Subscribe), ctx, opts)
+}
+
+// SubscribeConfigurationItems mocks base method.
+func (m *MockClient) SubscribeConfigurationItems(ctx context.Context, storeName string, keys []string, handler client.ConfigurationHandleFunction, opts ...client.ConfigurationOpt) (string, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, storeName, keys, handler}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SubscribeConfigurationItems", varargs...)
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SubscribeConfigurationItems indicates an expected call of SubscribeConfigurationItems.
+func (mr *MockClientMockRecorder) SubscribeConfigurationItems(ctx, storeName, keys, handler any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, storeName, keys, handler}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeConfigurationItems", reflect.TypeOf((*MockClient)(nil).SubscribeConfigurationItems), varargs...)
+}
+
+// SubscribeWithHandler mocks base method.
+func (m *MockClient) SubscribeWithHandler(ctx context.Context, opts client.SubscriptionOptions, handler client.SubscriptionHandleFunction) (func() error, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SubscribeWithHandler", ctx, opts, handler)
+	ret0, _ := ret[0].(func() error)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SubscribeWithHandler indicates an expected call of SubscribeWithHandler.
+func (mr *MockClientMockRecorder) SubscribeWithHandler(ctx, opts, handler any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeWithHandler", reflect.TypeOf((*MockClient)(nil).SubscribeWithHandler), ctx, opts, handler)
+}
+
+// TerminateWorkflowBeta1 mocks base method.
+func (m *MockClient) TerminateWorkflowBeta1(ctx context.Context, req *client.TerminateWorkflowRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TerminateWorkflowBeta1", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// TerminateWorkflowBeta1 indicates an expected call of TerminateWorkflowBeta1.
+func (mr *MockClientMockRecorder) TerminateWorkflowBeta1(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).TerminateWorkflowBeta1), ctx, req)
+}
+
+// TryLockAlpha1 mocks base method.
+func (m *MockClient) TryLockAlpha1(ctx context.Context, storeName string, request *client.LockRequest) (*client.LockResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TryLockAlpha1", ctx, storeName, request)
+	ret0, _ := ret[0].(*client.LockResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// TryLockAlpha1 indicates an expected call of TryLockAlpha1.
+func (mr *MockClientMockRecorder) TryLockAlpha1(ctx, storeName, request any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryLockAlpha1", reflect.TypeOf((*MockClient)(nil).TryLockAlpha1), ctx, storeName, request)
+}
+
+// UnlockAlpha1 mocks base method.
+func (m *MockClient) UnlockAlpha1(ctx context.Context, storeName string, request *client.UnlockRequest) (*client.UnlockResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UnlockAlpha1", ctx, storeName, request)
+	ret0, _ := ret[0].(*client.UnlockResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UnlockAlpha1 indicates an expected call of UnlockAlpha1.
+func (mr *MockClientMockRecorder) UnlockAlpha1(ctx, storeName, request any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockAlpha1", reflect.TypeOf((*MockClient)(nil).UnlockAlpha1), ctx, storeName, request)
+}
+
+// UnregisterActorReminder mocks base method.
+func (m *MockClient) UnregisterActorReminder(ctx context.Context, req *client.UnregisterActorReminderRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UnregisterActorReminder", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UnregisterActorReminder indicates an expected call of UnregisterActorReminder.
+func (mr *MockClientMockRecorder) UnregisterActorReminder(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterActorReminder", reflect.TypeOf((*MockClient)(nil).UnregisterActorReminder), ctx, req)
+}
+
+// UnregisterActorTimer mocks base method.
+func (m *MockClient) UnregisterActorTimer(ctx context.Context, req *client.UnregisterActorTimerRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UnregisterActorTimer", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UnregisterActorTimer indicates an expected call of UnregisterActorTimer.
+func (mr *MockClientMockRecorder) UnregisterActorTimer(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterActorTimer", reflect.TypeOf((*MockClient)(nil).UnregisterActorTimer), ctx, req)
+}
+
+// UnsubscribeConfigurationItems mocks base method.
+func (m *MockClient) UnsubscribeConfigurationItems(ctx context.Context, storeName, id string, opts ...client.ConfigurationOpt) error {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, storeName, id}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UnsubscribeConfigurationItems", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UnsubscribeConfigurationItems indicates an expected call of UnsubscribeConfigurationItems.
+func (mr *MockClientMockRecorder) UnsubscribeConfigurationItems(ctx, storeName, id any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, storeName, id}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsubscribeConfigurationItems", reflect.TypeOf((*MockClient)(nil).UnsubscribeConfigurationItems), varargs...)
+}
+
+// Wait mocks base method.
+func (m *MockClient) Wait(ctx context.Context, timeout time.Duration) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Wait", ctx, timeout)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Wait indicates an expected call of Wait.
+func (mr *MockClientMockRecorder) Wait(ctx, timeout any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Wait", reflect.TypeOf((*MockClient)(nil).Wait), ctx, timeout)
+}
+
+// WithAuthToken mocks base method.
+func (m *MockClient) WithAuthToken(token string) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "WithAuthToken", token)
+}
+
+// WithAuthToken indicates an expected call of WithAuthToken.
+func (mr *MockClientMockRecorder) WithAuthToken(token any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithAuthToken", reflect.TypeOf((*MockClient)(nil).WithAuthToken), token)
+}
+
+// WithTraceID mocks base method.
+func (m *MockClient) WithTraceID(ctx context.Context, id string) context.Context {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WithTraceID", ctx, id)
+	ret0, _ := ret[0].(context.Context)
+	return ret0
+}
+
+// WithTraceID indicates an expected call of WithTraceID.
+func (mr *MockClientMockRecorder) WithTraceID(ctx, id any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithTraceID", reflect.TypeOf((*MockClient)(nil).WithTraceID), ctx, id)
+}
diff --git a/actor/runtime/actor_runtime_test.go b/actor/runtime/actor_runtime_test.go
index 74bfe9c1..42439420 100644
--- a/actor/runtime/actor_runtime_test.go
+++ b/actor/runtime/actor_runtime_test.go
@@ -20,8 +20,8 @@ import (
 	actorErr "github.com/dapr/go-sdk/actor/error"
 	actorMock "github.com/dapr/go-sdk/actor/mock"
 
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
+	"go.uber.org/mock/gomock"
 )
 
 func TestNewActorRuntime(t *testing.T) {
diff --git a/actor/state/state_manager.go b/actor/state/state_manager.go
index 0bae7c9a..ef8e4cfd 100644
--- a/actor/state/state_manager.go
+++ b/actor/state/state_manager.go
@@ -167,7 +167,7 @@ func (s *stateManagerCtx) SetWithTTL(_ context.Context, stateName string, value
 		if metadata.Kind == None || metadata.Kind == Remove {
 			metadata.Kind = Update
 		}
-		s.stateChangeTracker.Store(stateName, NewChangeMetadata(metadata.Kind, value))
+		s.stateChangeTracker.Store(stateName, NewChangeMetadata(metadata.Kind, value).WithTTL(ttl))
 		return nil
 	}
 	s.stateChangeTracker.Store(stateName, (&ChangeMetadata{
diff --git a/actor/state/state_manager_test.go b/actor/state/state_manager_test.go
new file mode 100644
index 00000000..541c6fe6
--- /dev/null
+++ b/actor/state/state_manager_test.go
@@ -0,0 +1,1094 @@
+/*
+Copyright 2021 The Dapr Authors
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package state
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/dapr/go-sdk/actor/mock"
+	"github.com/dapr/go-sdk/actor/mock_client"
+	"github.com/dapr/go-sdk/client"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+)
+
+const (
+	testState = "state"
+	testValue = "value"
+	testTTL   = time.Second * 3600
+)
+
+func newMockStateManager(t *testing.T) *stateManager {
+	return &stateManager{
+		stateManagerCtx: newMockStateManagerCtx(t),
+	}
+}
+
+func newMockStateManagerCtx(t *testing.T) *stateManagerCtx {
+	ctrl := gomock.NewController(t)
+	return &stateManagerCtx{
+		actorTypeName: "test",
+		actorID:       "fn",
+		stateAsyncProvider: &DaprStateAsyncProvider{
+			daprClient:      mock_client.NewMockClient(ctrl),
+			stateSerializer: mock.NewMockCodec(ctrl),
+		},
+	}
+}
+
+func newGetActorStateRequest(sm *stateManagerCtx, key string) *client.GetActorStateRequest {
+	return &client.GetActorStateRequest{
+		ActorType: sm.actorTypeName,
+		ActorID:   sm.actorID,
+		KeyName:   key,
+	}
+}
+
+func newGetActorStateResponse(data []byte) *client.GetActorStateResponse {
+	return &client.GetActorStateResponse{Data: data}
+}
+
+func TestAdd_EmptyStateName(t *testing.T) {
+	sm := newMockStateManager(t)
+	err := sm.Add("", testValue)
+	require.Error(t, err)
+}
+
+func TestAdd_WithCachedStateChange(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name      string
+		kind      ChangeKind
+		shouldErr bool
+	}{
+		{"state change kind None", None, true},
+		{"state change kind Add", Add, true},
+		{"state change kind Update", Update, true},
+		{"state change kind Remove", Remove, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManager(t)
+			sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue})
+			mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient)
+			mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState)
+			mockResult := newGetActorStateResponse([]byte("result"))
+			mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil)
+
+			err := sm.Add(testState, testValue)
+			if tt.shouldErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+
+				val, ok := sm.stateChangeTracker.Load(testState)
+				require.True(t, ok)
+
+				metadata := val.(*ChangeMetadata)
+				assert.Equal(t, Update, metadata.Kind)
+				assert.Equal(t, testValue, metadata.Value)
+			}
+		})
+	}
+}
+
+func TestAdd_WithoutCachedStateChange(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name             string
+		stateProviderErr bool
+		duplicateState   bool
+	}{
+		{"state provider returns error", true, false},
+		{"state provider returns data", false, true},
+		{"successfully add new state", false, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManager(t)
+			mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient)
+			mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState)
+			mockResult := newGetActorStateResponse([]byte("result"))
+			if tt.stateProviderErr {
+				mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr"))
+			} else {
+				if tt.duplicateState {
+					mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil)
+				} else {
+					mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, nil)
+				}
+			}
+
+			err := sm.Add(testState, testValue)
+			if tt.stateProviderErr || tt.duplicateState {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+
+				val, ok := sm.stateChangeTracker.Load(testState)
+				require.True(t, ok)
+
+				metadata := val.(*ChangeMetadata)
+				assert.Equal(t, Add, metadata.Kind)
+				assert.Equal(t, testValue, metadata.Value)
+			}
+		})
+	}
+}
+
+func TestGet_EmptyStateName(t *testing.T) {
+	sm := newMockStateManager(t)
+	err := sm.Get("", testValue)
+	require.Error(t, err)
+}
+
+func TestGet_WithCachedStateChange(t *testing.T) {
+	tests := []struct {
+		name      string
+		kind      ChangeKind
+		shouldErr bool
+	}{
+		{"state change kind None", None, false},
+		{"state change kind Add", Add, false},
+		{"state change kind Update", Update, false},
+		{"state change kind Remove", Remove, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManager(t)
+			sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue})
+
+			var reply string
+			err := sm.Get(testState, &reply)
+			if tt.shouldErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, testValue, reply)
+			}
+		})
+	}
+}
+
+func TestGet_WithoutCachedStateChange(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name      string
+		shouldErr bool
+	}{
+		{"state provider returns error", true},
+		{"state provider returns data", false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManager(t)
+			mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient)
+			mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec)
+			mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState)
+			mockResult := newGetActorStateResponse([]byte("result"))
+			if tt.shouldErr {
+				mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr"))
+			} else {
+				mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil)
+				mockCodec.EXPECT().Unmarshal(mockResult.Data, testValue)
+			}
+
+			err := sm.Get(testState, testValue)
+			if tt.shouldErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+			}
+
+			val, ok := sm.stateChangeTracker.Load(testState)
+			require.True(t, ok)
+
+			metadata := val.(*ChangeMetadata)
+			assert.Equal(t, None, metadata.Kind)
+			assert.Equal(t, testValue, metadata.Value)
+		})
+	}
+}
+
+func TestSet_EmptyStateName(t *testing.T) {
+	sm := newMockStateManager(t)
+	err := sm.Set("", testValue)
+	require.Error(t, err)
+}
+
+func TestSet_WithCachedStateChange(t *testing.T) {
+	tests := []struct {
+		name       string
+		initKind   ChangeKind
+		expectKind ChangeKind
+	}{
+		{"state change kind None", None, Update},
+		{"state change kind Add", Add, Add},
+		{"state change kind Update", Update, Update},
+		{"state change kind Remove", Remove, Update},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManager(t)
+			sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.initKind, Value: testValue})
+
+			err := sm.Set(testState, testValue)
+			require.NoError(t, err)
+
+			val, ok := sm.stateChangeTracker.Load(testState)
+			require.True(t, ok)
+
+			metadata := val.(*ChangeMetadata)
+			assert.Equal(t, tt.expectKind, metadata.Kind)
+			assert.Equal(t, testValue, metadata.Value)
+		})
+	}
+}
+
+func TestSet_WithoutCachedStateChange(t *testing.T) {
+	sm := newMockStateManager(t)
+
+	err := sm.Set(testState, testValue)
+	require.NoError(t, err)
+
+	val, ok := sm.stateChangeTracker.Load(testState)
+	require.True(t, ok)
+
+	metadata := val.(*ChangeMetadata)
+	assert.Equal(t, Add, metadata.Kind)
+	assert.Equal(t, testValue, metadata.Value)
+}
+
+func TestRemove_EmptyStateName(t *testing.T) {
+	sm := newMockStateManager(t)
+	err := sm.Remove("")
+	require.Error(t, err)
+}
+
+func TestRemove_WithCachedStateChange(t *testing.T) {
+	tests := []struct {
+		name    string
+		kind    ChangeKind
+		inCache bool
+	}{
+		{"state change kind None", None, true},
+		{"state change kind Add", Add, false},
+		{"state change kind Update", Update, false},
+		{"state change kind Remove", Remove, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManager(t)
+			sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue})
+
+			err := sm.Remove(testState)
+			require.NoError(t, err)
+
+			val, ok := sm.stateChangeTracker.Load(testState)
+			if tt.inCache {
+				assert.Equal(t, Remove, val.(*ChangeMetadata).Kind)
+				assert.True(t, ok)
+			} else {
+				assert.Nil(t, val)
+				assert.False(t, ok)
+			}
+		})
+	}
+}
+
+func TestRemove_WithoutCachedStateChange(t *testing.T) {
+	ctx := context.Background()
+	mockResult := newGetActorStateResponse([]byte("result"))
+	mockErr := errors.New("mockErr")
+
+	tests := []struct {
+		name     string
+		mockFunc func(sm *stateManagerCtx, mc *mock_client.MockClient)
+	}{
+		{"state provider returns error", func(sm *stateManagerCtx, mc *mock_client.MockClient) {
+			mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(nil, mockErr)
+		}},
+		{"state provider returns data", func(sm *stateManagerCtx, mc *mock_client.MockClient) {
+			mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(mockResult, nil)
+		}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManager(t)
+			mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient)
+			tt.mockFunc(sm.stateManagerCtx, mockClient)
+			err := sm.Remove(testState)
+			require.NoError(t, err)
+		})
+	}
+}
+
+func TestContains_EmptyStateName(t *testing.T) {
+	sm := newMockStateManager(t)
+	res, err := sm.Contains("")
+	require.Error(t, err)
+	assert.False(t, res)
+}
+
+func TestContains_WithCachedStateChange(t *testing.T) {
+	tests := []struct {
+		name     string
+		kind     ChangeKind
+		expected bool
+	}{
+		{"state change kind None", None, true},
+		{"state change kind Add", Add, true},
+		{"state change kind Update", Update, true},
+		{"state change kind Remove", Remove, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManager(t)
+			sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue})
+
+			result, err := sm.Contains(testState)
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestContains_WithoutCachedStateChange(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name      string
+		shouldErr bool
+	}{
+		{"state provider returns error", true},
+		{"state provider returns data", false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManager(t)
+			mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient)
+			mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState)
+			mockResult := newGetActorStateResponse([]byte("result"))
+			if tt.shouldErr {
+				mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr"))
+			} else {
+				mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil)
+			}
+
+			result, err := sm.Contains(testState)
+			if tt.shouldErr {
+				require.Error(t, err)
+				assert.False(t, result)
+			} else {
+				require.NoError(t, err)
+				assert.True(t, result)
+			}
+		})
+	}
+}
+
+func TestSave_SingleCachedStateChange(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name         string
+		stateChanges *ChangeMetadata
+	}{
+		{"no state change", nil},
+		{"state change kind None", &ChangeMetadata{Kind: None, Value: testValue}},
+		{"state change kind Add", &ChangeMetadata{Kind: Add, Value: testValue}},
+		{"state change kind Update", &ChangeMetadata{Kind: Update, Value: testValue}},
+		{"state change kind Remove", &ChangeMetadata{Kind: Remove, Value: testValue}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManager(t)
+			mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient)
+			mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec)
+			if tt.stateChanges != nil {
+				sm.stateChangeTracker.Store(testState, tt.stateChanges)
+
+				if tt.stateChanges.Kind == Remove {
+					mockClient.EXPECT().SaveStateTransactionally(ctx, sm.actorTypeName, sm.actorID, gomock.Len(1))
+				} else if tt.stateChanges.Kind == Add || tt.stateChanges.Kind == Update {
+					mockClient.EXPECT().SaveStateTransactionally(ctx, sm.actorTypeName, sm.actorID, gomock.Len(1))
+					mockCodec.EXPECT().Marshal(tt.stateChanges.Value)
+				}
+			}
+
+			err := sm.Save()
+			require.NoError(t, err)
+		})
+	}
+}
+
+func TestSave_MultipleCachedStateChanges(t *testing.T) {
+	ctx := context.Background()
+	sm := newMockStateManager(t)
+	mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient)
+	mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec)
+
+	stateChanges := []struct {
+		stateName string
+		value     string
+		kind      ChangeKind
+	}{
+		{"stateNone", "valueNone", None},
+		{"stateAdd", "valueAdd", Add},
+		{"stateUpdate", "valueUpdate", Update},
+		{"stateRemove", "valueRemove", Remove},
+	}
+	for _, sc := range stateChanges {
+		sm.stateChangeTracker.Store(sc.stateName, &ChangeMetadata{Kind: sc.kind, Value: sc.value})
+	}
+
+	// 3 operations: 1 Add, 1 Update, 1 Remove
+	mockClient.EXPECT().SaveStateTransactionally(ctx, sm.actorTypeName, sm.actorID, gomock.Len(3))
+	// 2 times: 1 Add, 1 Update
+	mockCodec.EXPECT().Marshal(gomock.Any()).Times(2)
+
+	err := sm.Save()
+	require.NoError(t, err)
+}
+
+func TestFlush(t *testing.T) {
+	sm := newMockStateManager(t)
+	stateChanges := []struct {
+		stateName string
+		value     string
+		kind      ChangeKind
+	}{
+		{"stateNone", "valueNone", None},
+		{"stateAdd", "valueAdd", Add},
+		{"stateUpdate", "valueUpdate", Update},
+		{"stateRemove", "valueRemove", Remove},
+	}
+	for _, sc := range stateChanges {
+		sm.stateChangeTracker.Store(sc.stateName, &ChangeMetadata{Kind: sc.kind, Value: sc.value})
+	}
+
+	sm.Flush()
+
+	for _, sc := range stateChanges {
+		val, ok := sm.stateChangeTracker.Load(sc.stateName)
+		if sc.kind == Remove {
+			assert.Nil(t, val)
+			assert.False(t, ok)
+		} else {
+			metadata := val.(*ChangeMetadata)
+			assert.True(t, ok)
+			assert.Equal(t, None, metadata.Kind)
+			assert.Equal(t, sc.value, metadata.Value)
+		}
+	}
+}
+
+func TestStateManager_WithContext(t *testing.T) {
+	sm := newMockStateManager(t)
+	assert.Equal(t, sm.WithContext(), sm.stateManagerCtx)
+}
+
+func TestAdd_EmptyStateName_Context(t *testing.T) {
+	ctx := context.Background()
+	sm := newMockStateManagerCtx(t)
+	err := sm.Add(ctx, "", testValue)
+	require.Error(t, err)
+}
+
+func TestAdd_WithCachedStateChange_Context(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name      string
+		kind      ChangeKind
+		shouldErr bool
+	}{
+		{"state change kind None", None, true},
+		{"state change kind Add", Add, true},
+		{"state change kind Update", Update, true},
+		{"state change kind Remove", Remove, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManagerCtx(t)
+			sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue})
+			mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient)
+			mockRequest := newGetActorStateRequest(sm, testState)
+			mockResult := newGetActorStateResponse([]byte("result"))
+			mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil)
+
+			err := sm.Add(ctx, testState, testValue)
+			if tt.shouldErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+
+				val, ok := sm.stateChangeTracker.Load(testState)
+				require.True(t, ok)
+
+				metadata := val.(*ChangeMetadata)
+				assert.Equal(t, Update, metadata.Kind)
+				assert.Equal(t, testValue, metadata.Value)
+			}
+		})
+	}
+}
+
+func TestAdd_WithoutCachedStateChange_Context(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name             string
+		stateProviderErr bool
+		duplicateState   bool
+	}{
+		{"state provider returns error", true, false},
+		{"state provider returns data", false, true},
+		{"successfully add new state", false, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManagerCtx(t)
+			mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient)
+			mockRequest := newGetActorStateRequest(sm, testState)
+			mockResult := newGetActorStateResponse([]byte("result"))
+			if tt.stateProviderErr {
+				mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr"))
+			} else {
+				if tt.duplicateState {
+					mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil)
+				} else {
+					mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, nil)
+				}
+			}
+
+			err := sm.Add(ctx, testState, testValue)
+			if tt.stateProviderErr || tt.duplicateState {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+
+				val, ok := sm.stateChangeTracker.Load(testState)
+				require.True(t, ok)
+
+				metadata := val.(*ChangeMetadata)
+				assert.Equal(t, Add, metadata.Kind)
+				assert.Equal(t, testValue, metadata.Value)
+			}
+		})
+	}
+}
+
+func TestGet_EmptyStateName_Context(t *testing.T) {
+	ctx := context.Background()
+	sm := newMockStateManagerCtx(t)
+	err := sm.Get(ctx, "", testValue)
+	require.Error(t, err)
+}
+
+func TestGet_WithCachedStateChange_Context(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name      string
+		kind      ChangeKind
+		shouldErr bool
+	}{
+		{"state change kind None", None, false},
+		{"state change kind Add", Add, false},
+		{"state change kind Update", Update, false},
+		{"state change kind Remove", Remove, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManagerCtx(t)
+			sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue})
+
+			var reply string
+			err := sm.Get(ctx, testState, &reply)
+			if tt.shouldErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, testValue, reply)
+			}
+		})
+	}
+}
+
+func TestGet_WithoutCachedStateChange_Context(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name      string
+		shouldErr bool
+	}{
+		{"state provider returns error", true},
+		{"state provider returns data", false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManagerCtx(t)
+			mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient)
+			mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec)
+			mockRequest := newGetActorStateRequest(sm, testState)
+			mockResult := newGetActorStateResponse([]byte("result"))
+			if tt.shouldErr {
+				mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr"))
+			} else {
+				mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil)
+				mockCodec.EXPECT().Unmarshal(mockResult.Data, testValue)
+			}
+
+			err := sm.Get(ctx, testState, testValue)
+			if tt.shouldErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+			}
+
+			val, ok := sm.stateChangeTracker.Load(testState)
+			require.True(t, ok)
+
+			metadata := val.(*ChangeMetadata)
+			assert.Equal(t, None, metadata.Kind)
+			assert.Equal(t, testValue, metadata.Value)
+		})
+	}
+}
+
+func TestSet_EmptyStateName_Context(t *testing.T) {
+	ctx := context.Background()
+	sm := newMockStateManagerCtx(t)
+	err := sm.Set(ctx, "", testValue)
+	require.Error(t, err)
+}
+
+func TestSet_WithCachedStateChange_Context(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name       string
+		initKind   ChangeKind
+		expectKind ChangeKind
+	}{
+		{"state change kind None", None, Update},
+		{"state change kind Add", Add, Add},
+		{"state change kind Update", Update, Update},
+		{"state change kind Remove", Remove, Update},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManagerCtx(t)
+			sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.initKind, Value: testValue})
+
+			err := sm.Set(ctx, testState, testValue)
+			require.NoError(t, err)
+
+			val, ok := sm.stateChangeTracker.Load(testState)
+			require.True(t, ok)
+
+			metadata := val.(*ChangeMetadata)
+			assert.Equal(t, tt.expectKind, metadata.Kind)
+			assert.Equal(t, testValue, metadata.Value)
+		})
+	}
+}
+
+func TestSet_WithoutCachedStateChange_Context(t *testing.T) {
+	ctx := context.Background()
+	sm := newMockStateManagerCtx(t)
+
+	err := sm.Set(ctx, testState, testValue)
+	require.NoError(t, err)
+
+	val, ok := sm.stateChangeTracker.Load(testState)
+	require.True(t, ok)
+
+	metadata := val.(*ChangeMetadata)
+	assert.Equal(t, Add, metadata.Kind)
+	assert.Equal(t, testValue, metadata.Value)
+}
+
+func TestSetWithTTL_EmptyStateName_Context(t *testing.T) {
+	ctx := context.Background()
+	sm := newMockStateManagerCtx(t)
+	err := sm.SetWithTTL(ctx, "", testValue, testTTL)
+	require.Error(t, err)
+}
+
+func TestSetWithTTL_NegativeTTL_Context(t *testing.T) {
+	ctx := context.Background()
+	sm := newMockStateManagerCtx(t)
+	err := sm.SetWithTTL(ctx, testState, testValue, -testTTL)
+	require.Error(t, err)
+}
+
+func TestSetWithTTL_WithCachedStateChange_Context(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name       string
+		initKind   ChangeKind
+		expectKind ChangeKind
+	}{
+		{"state change kind None", None, Update},
+		{"state change kind Add", Add, Add},
+		{"state change kind Update", Update, Update},
+		{"state change kind Remove", Remove, Update},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManagerCtx(t)
+			sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.initKind, Value: testValue})
+
+			err := sm.SetWithTTL(ctx, testState, testValue, testTTL)
+			require.NoError(t, err)
+
+			val, ok := sm.stateChangeTracker.Load(testState)
+			require.True(t, ok)
+
+			metadata := val.(*ChangeMetadata)
+			assert.Equal(t, tt.expectKind, metadata.Kind)
+			assert.Equal(t, testValue, metadata.Value)
+			assert.Equal(t, testTTL, *metadata.TTL)
+		})
+	}
+}
+
+func TestSetWithTTL_WithoutCachedStateChange_Context(t *testing.T) {
+	ctx := context.Background()
+	sm := newMockStateManagerCtx(t)
+
+	err := sm.SetWithTTL(ctx, testState, testValue, testTTL)
+	require.NoError(t, err)
+
+	val, ok := sm.stateChangeTracker.Load(testState)
+	require.True(t, ok)
+
+	metadata := val.(*ChangeMetadata)
+	assert.Equal(t, Add, metadata.Kind)
+	assert.Equal(t, testValue, metadata.Value)
+	assert.Equal(t, testTTL, *metadata.TTL)
+}
+
+func TestRemove_EmptyStateName_Context(t *testing.T) {
+	ctx := context.Background()
+	sm := newMockStateManagerCtx(t)
+	err := sm.Remove(ctx, "")
+	require.Error(t, err)
+}
+
+func TestRemove_WithCachedStateChange_Context(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name    string
+		kind    ChangeKind
+		inCache bool
+	}{
+		{"state change kind None", None, true},
+		{"state change kind Add", Add, false},
+		{"state change kind Update", Update, false},
+		{"state change kind Remove", Remove, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManagerCtx(t)
+			sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue})
+
+			err := sm.Remove(ctx, testState)
+			require.NoError(t, err)
+
+			val, ok := sm.stateChangeTracker.Load(testState)
+			if tt.inCache {
+				assert.Equal(t, Remove, val.(*ChangeMetadata).Kind)
+				assert.True(t, ok)
+			} else {
+				assert.Nil(t, val)
+				assert.False(t, ok)
+			}
+		})
+	}
+}
+
+func TestRemove_WithoutCachedStateChange_Context(t *testing.T) {
+	ctx := context.Background()
+	mockResult := newGetActorStateResponse([]byte("result"))
+	mockErr := errors.New("mockErr")
+
+	tests := []struct {
+		name     string
+		mockFunc func(sm *stateManagerCtx, mc *mock_client.MockClient)
+	}{
+		{"state provider returns error", func(sm *stateManagerCtx, mc *mock_client.MockClient) {
+			mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(nil, mockErr)
+		}},
+		{"state provider returns data", func(sm *stateManagerCtx, mc *mock_client.MockClient) {
+			mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(mockResult, nil)
+		}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManagerCtx(t)
+			mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient)
+			tt.mockFunc(sm, mockClient)
+			err := sm.Remove(ctx, testState)
+			require.NoError(t, err)
+		})
+	}
+}
+
+func TestContains_EmptyStateName_Context(t *testing.T) {
+	ctx := context.Background()
+	sm := newMockStateManagerCtx(t)
+	res, err := sm.Contains(ctx, "")
+	require.Error(t, err)
+	assert.False(t, res)
+}
+
+func TestContains_WithCachedStateChange_Context(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name     string
+		kind     ChangeKind
+		expected bool
+	}{
+		{"state change kind None", None, true},
+		{"state change kind Add", Add, true},
+		{"state change kind Update", Update, true},
+		{"state change kind Remove", Remove, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManagerCtx(t)
+			sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue})
+
+			result, err := sm.Contains(ctx, testState)
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestContains_WithoutCachedStateChange_Context(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name      string
+		shouldErr bool
+	}{
+		{"state provider returns error", true},
+		{"state provider returns data", false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManagerCtx(t)
+			mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient)
+			mockRequest := newGetActorStateRequest(sm, testState)
+			mockResult := newGetActorStateResponse([]byte("result"))
+			if tt.shouldErr {
+				mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr"))
+			} else {
+				mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil)
+			}
+
+			result, err := sm.Contains(ctx, testState)
+			if tt.shouldErr {
+				require.Error(t, err)
+				assert.False(t, result)
+			} else {
+				require.NoError(t, err)
+				assert.True(t, result)
+			}
+		})
+	}
+}
+
+func TestSave_SingleCachedStateChange_Context(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name         string
+		stateChanges *ChangeMetadata
+	}{
+		{"no state change", nil},
+		{"state change kind None", &ChangeMetadata{Kind: None, Value: testValue}},
+		{"state change kind Add", &ChangeMetadata{Kind: Add, Value: testValue}},
+		{"state change kind Update", &ChangeMetadata{Kind: Update, Value: testValue}},
+		{"state change kind Remove", &ChangeMetadata{Kind: Remove, Value: testValue}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sm := newMockStateManagerCtx(t)
+			mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient)
+			mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec)
+			if tt.stateChanges != nil {
+				sm.stateChangeTracker.Store(testState, tt.stateChanges)
+
+				if tt.stateChanges.Kind == Remove {
+					mockClient.EXPECT().SaveStateTransactionally(ctx, sm.actorTypeName, sm.actorID, gomock.Len(1))
+				} else if tt.stateChanges.Kind == Add || tt.stateChanges.Kind == Update {
+					mockClient.EXPECT().SaveStateTransactionally(ctx, sm.actorTypeName, sm.actorID, gomock.Len(1))
+					mockCodec.EXPECT().Marshal(tt.stateChanges.Value)
+				}
+			}
+
+			err := sm.Save(ctx)
+			require.NoError(t, err)
+		})
+	}
+}
+
+func TestSave_MultipleCachedStateChanges_Context(t *testing.T) {
+	ctx := context.Background()
+	sm := newMockStateManagerCtx(t)
+	mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient)
+	mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec)
+
+	stateChanges := []struct {
+		stateName string
+		value     string
+		kind      ChangeKind
+	}{
+		{"stateNone", "valueNone", None},
+		{"stateAdd", "valueAdd", Add},
+		{"stateUpdate", "valueUpdate", Update},
+		{"stateRemove", "valueRemove", Remove},
+	}
+	for _, sc := range stateChanges {
+		sm.stateChangeTracker.Store(sc.stateName, &ChangeMetadata{Kind: sc.kind, Value: sc.value})
+	}
+
+	// 3 operations: 1 Add, 1 Update, 1 Remove
+	mockClient.EXPECT().SaveStateTransactionally(ctx, sm.actorTypeName, sm.actorID, gomock.Len(3))
+	// 2 times: 1 Add, 1 Update
+	mockCodec.EXPECT().Marshal(gomock.Any()).Times(2)
+
+	err := sm.Save(ctx)
+	require.NoError(t, err)
+}
+
+func TestFlush_Context(t *testing.T) {
+	ctx := context.Background()
+	sm := newMockStateManagerCtx(t)
+	stateChanges := []struct {
+		stateName string
+		value     string
+		kind      ChangeKind
+	}{
+		{"stateNone", "valueNone", None},
+		{"stateAdd", "valueAdd", Add},
+		{"stateUpdate", "valueUpdate", Update},
+		{"stateRemove", "valueRemove", Remove},
+	}
+	for _, sc := range stateChanges {
+		sm.stateChangeTracker.Store(sc.stateName, &ChangeMetadata{Kind: sc.kind, Value: sc.value})
+	}
+
+	sm.Flush(ctx)
+
+	for _, sc := range stateChanges {
+		val, ok := sm.stateChangeTracker.Load(sc.stateName)
+		if sc.kind == Remove {
+			assert.Nil(t, val)
+			assert.False(t, ok)
+		} else {
+			metadata := val.(*ChangeMetadata)
+			assert.True(t, ok)
+			assert.Equal(t, None, metadata.Kind)
+			assert.Equal(t, sc.value, metadata.Value)
+		}
+	}
+}
+
+func TestNewActorStateManager(t *testing.T) {
+	type args struct {
+		actorTypeName      string
+		actorID            string
+		stateAsyncProvider *DaprStateAsyncProvider
+	}
+	tests := []struct {
+		name string
+		args args
+		want *stateManager
+	}{
+		{
+			name: "init",
+			args: args{
+				actorTypeName:      "test",
+				actorID:            "fn",
+				stateAsyncProvider: &DaprStateAsyncProvider{},
+			},
+			want: &stateManager{
+				&stateManagerCtx{
+					actorTypeName:      "test",
+					actorID:            "fn",
+					stateAsyncProvider: &DaprStateAsyncProvider{},
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := NewActorStateManager(tt.args.actorTypeName, tt.args.actorID, tt.args.stateAsyncProvider); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("NewActorStateManager() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestNewActorStateManagerContext(t *testing.T) {
+	type args struct {
+		actorTypeName      string
+		actorID            string
+		stateAsyncProvider *DaprStateAsyncProvider
+	}
+	tests := []struct {
+		name string
+		args args
+		want *stateManagerCtx
+	}{
+		{
+			name: "init",
+			args: args{
+				actorTypeName:      "test",
+				actorID:            "fn",
+				stateAsyncProvider: &DaprStateAsyncProvider{},
+			},
+			want: &stateManagerCtx{
+				actorTypeName:      "test",
+				actorID:            "fn",
+				stateAsyncProvider: &DaprStateAsyncProvider{},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := NewActorStateManagerContext(tt.args.actorTypeName, tt.args.actorID, tt.args.stateAsyncProvider); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("NewActorStateManagerContext() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/go.mod b/go.mod
index 3817e3b2..153bcf21 100644
--- a/go.mod
+++ b/go.mod
@@ -5,10 +5,10 @@ go 1.22.5
 require (
 	github.com/dapr/dapr v1.14.0-rc.2
 	github.com/go-chi/chi/v5 v5.1.0
-	github.com/golang/mock v1.6.0
 	github.com/google/uuid v1.6.0
 	github.com/microsoft/durabletask-go v0.5.0
 	github.com/stretchr/testify v1.9.0
+	go.uber.org/mock v0.4.0
 	google.golang.org/grpc v1.65.0
 	google.golang.org/protobuf v1.34.2
 	gopkg.in/yaml.v3 v3.0.1
diff --git a/go.sum b/go.sum
index cd8f26cc..ffea3972 100644
--- a/go.sum
+++ b/go.sum
@@ -12,8 +12,6 @@ github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
 github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
-github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
-github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
@@ -34,43 +32,22 @@ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRI
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 go.opentelemetry.io/otel v1.27.0 h1:9BZoF3yMK/O1AafMiQTVu0YDj5Ea4hPhxCs7sGva+cg=
 go.opentelemetry.io/otel v1.27.0/go.mod h1:DMpAK8fzYRzs+bi3rS5REupisuqTheUlSZJ1WnZaPAQ=
 go.opentelemetry.io/otel/metric v1.27.0 h1:hvj3vdEKyeCi4YaYfNjv2NUje8FqKqUY8IlF0FxV/ik=
 go.opentelemetry.io/otel/metric v1.27.0/go.mod h1:mVFgmRlhljgBiuk/MP/oKylr4hs85GZAylncepAX/ak=
 go.opentelemetry.io/otel/trace v1.27.0 h1:IqYb813p7cmbHk0a5y6pD5JPakbVfftRXABGt5/Rscw=
 go.opentelemetry.io/otel/trace v1.27.0/go.mod h1:6RiD1hkAprV4/q+yd2ln1HG9GoPx39SuvvstaLBl+l4=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU=
+go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc=
 golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8 h1:yixxcjnhBmY0nkL253HFVIm0JsFHwrHdT3Yh6szTnfY=
 golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8/go.mod h1:jj3sYF3dwk5D+ghuXyeI3r5MFf+NT2An6/9dOA95KSI=
-golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
 golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
 golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20240624140628-dc46fd24d27d h1:k3zyW3BYYR30e8v3x0bTDdE9vpYFjZHK+HcyqkrppWk=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20240624140628-dc46fd24d27d/go.mod h1:Ue6ibwXGpU+dqIcODieyLOcgj7z8+IcskoNIgZxtrFY=
 google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc=