func (m *MockExecutionStore) GetAllHistoryTreeBranches(request *persistence.GetAllHistoryTreeBranchesRequest) (*persistence.InternalGetAllHistoryTreeBranchesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllHistoryTreeBranches", request)
	ret0, _ := ret[0].(*persistence.InternalGetAllHistoryTreeBranchesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
GetAllHistoryTreeBranches 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)
}
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
}
func (mr *MockMetadataStoreMockRecorder) DeleteNamespace(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamespace", reflect.TypeOf((*MockMetadataStore)(nil).DeleteNamespace), request)
}
func (m *MockMetadataStore) DeleteNamespaceByName(request *persistence.DeleteNamespaceByNameRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNamespaceByName", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockMetadataStoreMockRecorder) DeleteNamespaceByName(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamespaceByName", reflect.TypeOf((*MockMetadataStore)(nil).DeleteNamespaceByName), request)
}
func (m *MockMetadataStore) GetMetadata() (*persistence.GetMetadataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetadata")
	ret0, _ := ret[0].(*persistence.GetMetadataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockMetadataStoreMockRecorder) GetMetadata() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockMetadataStore)(nil).GetMetadata))
}
func (m *MockMetadataStore) GetName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetName")
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockMetadataStoreMockRecorder) GetName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockMetadataStore)(nil).GetName))
}
func (m *MockMetadataStore) GetNamespace(request *persistence.GetNamespaceRequest) (*persistence.InternalGetNamespaceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespace", request)
	ret0, _ := ret[0].(*persistence.InternalGetNamespaceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockMetadataStoreMockRecorder) GetNamespace(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespace", reflect.TypeOf((*MockMetadataStore)(nil).GetNamespace), request)
}
func (m *MockMetadataStore) ListNamespaces(request *persistence.ListNamespacesRequest) (*persistence.InternalListNamespacesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNamespaces", request)
	ret0, _ := ret[0].(*persistence.InternalListNamespacesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockMetadataStoreMockRecorder) ListNamespaces(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNamespaces", reflect.TypeOf((*MockMetadataStore)(nil).ListNamespaces), request)
}
func (m *MockMetadataStore) UpdateNamespace(request *persistence.InternalUpdateNamespaceRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNamespace", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockMetadataStoreMockRecorder) UpdateNamespace(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNamespace", reflect.TypeOf((*MockMetadataStore)(nil).UpdateNamespace), request)
}
type MockClusterMetadataStore struct {
	ctrl     *gomock.Controller
	recorder *MockClusterMetadataStoreMockRecorder
}
type MockClusterMetadataStoreMockRecorder struct {
	mock *MockClusterMetadataStore
}
func NewMockClusterMetadataStore(ctrl *gomock.Controller) *MockClusterMetadataStore {
	mock := &MockClusterMetadataStore{ctrl: ctrl}
	mock.recorder = &MockClusterMetadataStoreMockRecorder{mock}
	return mock
}
func (m *MockClusterMetadataStore) EXPECT() *MockClusterMetadataStoreMockRecorder {
	return m.recorder
}
func (m *MockClusterMetadataStore) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}
func (mr *MockClusterMetadataStoreMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClusterMetadataStore)(nil).Close))
}
func (m *MockClusterMetadataStore) GetClusterMembers(request *persistence.GetClusterMembersRequest) (*persistence.GetClusterMembersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterMembers", request)
	ret0, _ := ret[0].(*persistence.GetClusterMembersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockClusterMetadataStoreMockRecorder) GetClusterMembers(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMembers", reflect.TypeOf((*MockClusterMetadataStore)(nil).GetClusterMembers), request)
}
func (m *MockClusterMetadataStore) GetClusterMetadata() (*persistence.InternalGetClusterMetadataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterMetadata")
	ret0, _ := ret[0].(*persistence.InternalGetClusterMetadataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockClusterMetadataStoreMockRecorder) GetClusterMetadata() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMetadata", reflect.TypeOf((*MockClusterMetadataStore)(nil).GetClusterMetadata))
}
func (m *MockClusterMetadataStore) GetName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetName")
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockClusterMetadataStoreMockRecorder) GetName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockClusterMetadataStore)(nil).GetName))
}
func (m *MockClusterMetadataStore) PruneClusterMembership(request *persistence.PruneClusterMembershipRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PruneClusterMembership", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockClusterMetadataStoreMockRecorder) PruneClusterMembership(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PruneClusterMembership", reflect.TypeOf((*MockClusterMetadataStore)(nil).PruneClusterMembership), request)
}
func (m *MockClusterMetadataStore) SaveClusterMetadata(request *persistence.InternalSaveClusterMetadataRequest) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveClusterMetadata", request)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockClusterMetadataStoreMockRecorder) SaveClusterMetadata(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveClusterMetadata", reflect.TypeOf((*MockClusterMetadataStore)(nil).SaveClusterMetadata), request)
}
func (m *MockClusterMetadataStore) UpsertClusterMembership(request *persistence.UpsertClusterMembershipRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertClusterMembership", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockClusterMetadataStoreMockRecorder) UpsertClusterMembership(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertClusterMembership", reflect.TypeOf((*MockClusterMetadataStore)(nil).UpsertClusterMembership), request)
}
type MockExecutionStore struct {
	ctrl     *gomock.Controller
	recorder *MockExecutionStoreMockRecorder
}
type MockExecutionStoreMockRecorder struct {
	mock *MockExecutionStore
}
func NewMockExecutionStore(ctrl *gomock.Controller) *MockExecutionStore {
	mock := &MockExecutionStore{ctrl: ctrl}
	mock.recorder = &MockExecutionStoreMockRecorder{mock}
	return mock
}
func (m *MockExecutionStore) EXPECT() *MockExecutionStoreMockRecorder {
	return m.recorder
}
func (m *MockExecutionStore) AddTasks(request *persistence.InternalAddTasksRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTasks", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExecutionStoreMockRecorder) AddTasks(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTasks", reflect.TypeOf((*MockExecutionStore)(nil).AddTasks), request)
}
func (m *MockExecutionStore) AppendHistoryNodes(request *persistence.InternalAppendHistoryNodesRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppendHistoryNodes", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExecutionStoreMockRecorder) AppendHistoryNodes(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendHistoryNodes", reflect.TypeOf((*MockExecutionStore)(nil).AppendHistoryNodes), request)
}
func (m *MockExecutionStore) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}
func (mr *MockExecutionStoreMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockExecutionStore)(nil).Close))
}
func (m *MockExecutionStore) CompleteReplicationTask(request *persistence.CompleteReplicationTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteReplicationTask", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExecutionStoreMockRecorder) CompleteReplicationTask(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteReplicationTask", reflect.TypeOf((*MockExecutionStore)(nil).CompleteReplicationTask), request)
}
func (m *MockExecutionStore) CompleteTimerTask(request *persistence.CompleteTimerTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteTimerTask", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExecutionStoreMockRecorder) CompleteTimerTask(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTimerTask", reflect.TypeOf((*MockExecutionStore)(nil).CompleteTimerTask), request)
}
func (m *MockExecutionStore) CompleteTransferTask(request *persistence.CompleteTransferTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteTransferTask", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExecutionStoreMockRecorder) CompleteTransferTask(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTransferTask", reflect.TypeOf((*MockExecutionStore)(nil).CompleteTransferTask), request)
}
func (m *MockExecutionStore) CompleteVisibilityTask(request *persistence.CompleteVisibilityTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteVisibilityTask", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExecutionStoreMockRecorder) CompleteVisibilityTask(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteVisibilityTask", reflect.TypeOf((*MockExecutionStore)(nil).CompleteVisibilityTask), request)
}
func (m *MockExecutionStore) ConflictResolveWorkflowExecution(request *persistence.InternalConflictResolveWorkflowExecutionRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConflictResolveWorkflowExecution", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExecutionStoreMockRecorder) ConflictResolveWorkflowExecution(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConflictResolveWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).ConflictResolveWorkflowExecution), request)
}
func (m *MockExecutionStore) CreateWorkflowExecution(request *persistence.InternalCreateWorkflowExecutionRequest) (*persistence.InternalCreateWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWorkflowExecution", request)
	ret0, _ := ret[0].(*persistence.InternalCreateWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockExecutionStoreMockRecorder) CreateWorkflowExecution(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).CreateWorkflowExecution), request)
}
func (m *MockExecutionStore) DeleteCurrentWorkflowExecution(request *persistence.DeleteCurrentWorkflowExecutionRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCurrentWorkflowExecution", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExecutionStoreMockRecorder) DeleteCurrentWorkflowExecution(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCurrentWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).DeleteCurrentWorkflowExecution), request)
}
func (m *MockExecutionStore) DeleteHistoryBranch(request *persistence.InternalDeleteHistoryBranchRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHistoryBranch", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExecutionStoreMockRecorder) DeleteHistoryBranch(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHistoryBranch", reflect.TypeOf((*MockExecutionStore)(nil).DeleteHistoryBranch), request)
}
func (m *MockExecutionStore) DeleteHistoryNodes(request *persistence.InternalDeleteHistoryNodesRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHistoryNodes", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExecutionStoreMockRecorder) DeleteHistoryNodes(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHistoryNodes", reflect.TypeOf((*MockExecutionStore)(nil).DeleteHistoryNodes), request)
}
func (m *MockExecutionStore) DeleteReplicationTaskFromDLQ(request *persistence.DeleteReplicationTaskFromDLQRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReplicationTaskFromDLQ", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExecutionStoreMockRecorder) DeleteReplicationTaskFromDLQ(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationTaskFromDLQ", reflect.TypeOf((*MockExecutionStore)(nil).DeleteReplicationTaskFromDLQ), request)
}
func (m *MockExecutionStore) DeleteWorkflowExecution(request *persistence.DeleteWorkflowExecutionRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkflowExecution", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExecutionStoreMockRecorder) DeleteWorkflowExecution(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).DeleteWorkflowExecution), request)
}
func (m *MockExecutionStore) ForkHistoryBranch(request *persistence.InternalForkHistoryBranchRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForkHistoryBranch", request)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockExecutionStoreMockRecorder) ForkHistoryBranch(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForkHistoryBranch", reflect.TypeOf((*MockExecutionStore)(nil).ForkHistoryBranch), request)
}