func (m *MockMetadataStore) DeleteNamespace(request *persistence.DeleteNamespaceRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNamespace", request)
	ret0, _ := ret[0].(error)
	return ret0
}
DeleteNamespace mocks base method.
package mock
import (
	reflect "reflect"
	gomock "github.com/golang/mock/gomock"
	common "go.temporal.io/api/common/v1"
	persistence "go.temporal.io/server/common/persistence"
)
type MockShardStore struct {
	ctrl     *gomock.Controller
	recorder *MockShardStoreMockRecorder
}
type MockShardStoreMockRecorder struct {
	mock *MockShardStore
}
func NewMockShardStore(ctrl *gomock.Controller) *MockShardStore {
	mock := &MockShardStore{ctrl: ctrl}
	mock.recorder = &MockShardStoreMockRecorder{mock}
	return mock
}
func (m *MockShardStore) EXPECT() *MockShardStoreMockRecorder {
	return m.recorder
}
func (m *MockShardStore) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}
func (mr *MockShardStoreMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockShardStore)(nil).Close))
}
func (m *MockShardStore) CreateShard(request *persistence.InternalCreateShardRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateShard", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockShardStoreMockRecorder) CreateShard(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateShard", reflect.TypeOf((*MockShardStore)(nil).CreateShard), request)
}
func (m *MockShardStore) GetClusterName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterName")
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockShardStoreMockRecorder) GetClusterName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterName", reflect.TypeOf((*MockShardStore)(nil).GetClusterName))
}
func (m *MockShardStore) GetName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetName")
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockShardStoreMockRecorder) GetName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockShardStore)(nil).GetName))
}
func (m *MockShardStore) GetShard(request *persistence.InternalGetShardRequest) (*persistence.InternalGetShardResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetShard", request)
	ret0, _ := ret[0].(*persistence.InternalGetShardResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockShardStoreMockRecorder) GetShard(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShard", reflect.TypeOf((*MockShardStore)(nil).GetShard), request)
}
func (m *MockShardStore) UpdateShard(request *persistence.InternalUpdateShardRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateShard", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockShardStoreMockRecorder) UpdateShard(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateShard", reflect.TypeOf((*MockShardStore)(nil).UpdateShard), request)
}
type MockTaskStore struct {
	ctrl     *gomock.Controller
	recorder *MockTaskStoreMockRecorder
}
type MockTaskStoreMockRecorder struct {
	mock *MockTaskStore
}
func NewMockTaskStore(ctrl *gomock.Controller) *MockTaskStore {
	mock := &MockTaskStore{ctrl: ctrl}
	mock.recorder = &MockTaskStoreMockRecorder{mock}
	return mock
}
func (m *MockTaskStore) EXPECT() *MockTaskStoreMockRecorder {
	return m.recorder
}
func (m *MockTaskStore) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}
func (mr *MockTaskStoreMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockTaskStore)(nil).Close))
}
func (m *MockTaskStore) CompleteTask(request *persistence.CompleteTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteTask", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockTaskStoreMockRecorder) CompleteTask(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTask", reflect.TypeOf((*MockTaskStore)(nil).CompleteTask), request)
}
func (m *MockTaskStore) CompleteTasksLessThan(request *persistence.CompleteTasksLessThanRequest) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteTasksLessThan", request)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockTaskStoreMockRecorder) CompleteTasksLessThan(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTasksLessThan", reflect.TypeOf((*MockTaskStore)(nil).CompleteTasksLessThan), request)
}
func (m *MockTaskStore) CreateTaskQueue(request *persistence.InternalCreateTaskQueueRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTaskQueue", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockTaskStoreMockRecorder) CreateTaskQueue(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).CreateTaskQueue), request)
}
func (m *MockTaskStore) CreateTasks(request *persistence.InternalCreateTasksRequest) (*persistence.CreateTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTasks", request)
	ret0, _ := ret[0].(*persistence.CreateTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockTaskStoreMockRecorder) CreateTasks(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTasks", reflect.TypeOf((*MockTaskStore)(nil).CreateTasks), request)
}
func (m *MockTaskStore) DeleteTaskQueue(request *persistence.DeleteTaskQueueRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTaskQueue", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockTaskStoreMockRecorder) DeleteTaskQueue(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).DeleteTaskQueue), request)
}
func (m *MockTaskStore) ExtendLease(request *persistence.InternalExtendLeaseRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExtendLease", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockTaskStoreMockRecorder) ExtendLease(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExtendLease", reflect.TypeOf((*MockTaskStore)(nil).ExtendLease), request)
}
func (m *MockTaskStore) GetName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetName")
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockTaskStoreMockRecorder) GetName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockTaskStore)(nil).GetName))
}
func (m *MockTaskStore) GetTaskQueue(request *persistence.InternalGetTaskQueueRequest) (*persistence.InternalGetTaskQueueResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTaskQueue", request)
	ret0, _ := ret[0].(*persistence.InternalGetTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockTaskStoreMockRecorder) GetTaskQueue(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).GetTaskQueue), request)
}
func (m *MockTaskStore) GetTasks(request *persistence.GetTasksRequest) (*persistence.InternalGetTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTasks", request)
	ret0, _ := ret[0].(*persistence.InternalGetTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockTaskStoreMockRecorder) GetTasks(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTasks", reflect.TypeOf((*MockTaskStore)(nil).GetTasks), request)
}
func (m *MockTaskStore) ListTaskQueue(request *persistence.ListTaskQueueRequest) (*persistence.InternalListTaskQueueResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTaskQueue", request)
	ret0, _ := ret[0].(*persistence.InternalListTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockTaskStoreMockRecorder) ListTaskQueue(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).ListTaskQueue), request)
}
func (m *MockTaskStore) UpdateTaskQueue(request *persistence.InternalUpdateTaskQueueRequest) (*persistence.UpdateTaskQueueResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskQueue", request)
	ret0, _ := ret[0].(*persistence.UpdateTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockTaskStoreMockRecorder) UpdateTaskQueue(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).UpdateTaskQueue), request)
}
type MockMetadataStore struct {
	ctrl     *gomock.Controller
	recorder *MockMetadataStoreMockRecorder
}
type MockMetadataStoreMockRecorder struct {
	mock *MockMetadataStore
}
func NewMockMetadataStore(ctrl *gomock.Controller) *MockMetadataStore {
	mock := &MockMetadataStore{ctrl: ctrl}
	mock.recorder = &MockMetadataStoreMockRecorder{mock}
	return mock
}
func (m *MockMetadataStore) EXPECT() *MockMetadataStoreMockRecorder {
	return m.recorder
}
func (m *MockMetadataStore) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}
func (mr *MockMetadataStoreMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockMetadataStore)(nil).Close))
}
func (m *MockMetadataStore) CreateNamespace(request *persistence.InternalCreateNamespaceRequest) (*persistence.CreateNamespaceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNamespace", request)
	ret0, _ := ret[0].(*persistence.CreateNamespaceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockMetadataStoreMockRecorder) CreateNamespace(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNamespace", reflect.TypeOf((*MockMetadataStore)(nil).CreateNamespace), request)
}