go.temporal.io/server@v1.23.0/common/persistence/mock/store_mock.go

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

// Code generated by MockGen. DO NOT EDIT.
// Source: persistence_interface.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	common "go.temporal.io/api/common/v1"
	persistence "go.temporal.io/server/common/persistence"
)

// MockShardStore is a mock of ShardStore interface.
type MockShardStore struct {
	ctrl     *gomock.Controller
	recorder *MockShardStoreMockRecorder
}

// MockShardStoreMockRecorder is the mock recorder for MockShardStore.
type MockShardStoreMockRecorder struct {
	mock *MockShardStore
}

// NewMockShardStore creates a new mock instance.
func NewMockShardStore(ctrl *gomock.Controller) *MockShardStore {
	mock := &MockShardStore{ctrl: ctrl}
	mock.recorder = &MockShardStoreMockRecorder{mock}
	return mock
}

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

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

// AssertShardOwnership indicates an expected call of AssertShardOwnership.
func (mr *MockShardStoreMockRecorder) AssertShardOwnership(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssertShardOwnership", reflect.TypeOf((*MockShardStore)(nil).AssertShardOwnership), ctx, request)
}

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

// Close indicates an expected call of 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))
}

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

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

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

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

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

// GetOrCreateShard indicates an expected call of GetOrCreateShard.
func (mr *MockShardStoreMockRecorder) GetOrCreateShard(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrCreateShard", reflect.TypeOf((*MockShardStore)(nil).GetOrCreateShard), ctx, request)
}

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

// UpdateShard indicates an expected call of UpdateShard.
func (mr *MockShardStoreMockRecorder) UpdateShard(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateShard", reflect.TypeOf((*MockShardStore)(nil).UpdateShard), ctx, request)
}

// MockTaskStore is a mock of TaskStore interface.
type MockTaskStore struct {
	ctrl     *gomock.Controller
	recorder *MockTaskStoreMockRecorder
}

// MockTaskStoreMockRecorder is the mock recorder for MockTaskStore.
type MockTaskStoreMockRecorder struct {
	mock *MockTaskStore
}

// NewMockTaskStore creates a new mock instance.
func NewMockTaskStore(ctrl *gomock.Controller) *MockTaskStore {
	mock := &MockTaskStore{ctrl: ctrl}
	mock.recorder = &MockTaskStoreMockRecorder{mock}
	return mock
}

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

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

// Close indicates an expected call of 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))
}

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

// CompleteTask indicates an expected call of CompleteTask.
func (mr *MockTaskStoreMockRecorder) CompleteTask(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTask", reflect.TypeOf((*MockTaskStore)(nil).CompleteTask), ctx, request)
}

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

// CompleteTasksLessThan indicates an expected call of CompleteTasksLessThan.
func (mr *MockTaskStoreMockRecorder) CompleteTasksLessThan(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTasksLessThan", reflect.TypeOf((*MockTaskStore)(nil).CompleteTasksLessThan), ctx, request)
}

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

// CountTaskQueuesByBuildId indicates an expected call of CountTaskQueuesByBuildId.
func (mr *MockTaskStoreMockRecorder) CountTaskQueuesByBuildId(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountTaskQueuesByBuildId", reflect.TypeOf((*MockTaskStore)(nil).CountTaskQueuesByBuildId), ctx, request)
}

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

// CreateTaskQueue indicates an expected call of CreateTaskQueue.
func (mr *MockTaskStoreMockRecorder) CreateTaskQueue(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).CreateTaskQueue), ctx, request)
}

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

// CreateTasks indicates an expected call of CreateTasks.
func (mr *MockTaskStoreMockRecorder) CreateTasks(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTasks", reflect.TypeOf((*MockTaskStore)(nil).CreateTasks), ctx, request)
}

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

// DeleteTaskQueue indicates an expected call of DeleteTaskQueue.
func (mr *MockTaskStoreMockRecorder) DeleteTaskQueue(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).DeleteTaskQueue), ctx, request)
}

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

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

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

// GetTaskQueue indicates an expected call of GetTaskQueue.
func (mr *MockTaskStoreMockRecorder) GetTaskQueue(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).GetTaskQueue), ctx, request)
}

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

// GetTaskQueueUserData indicates an expected call of GetTaskQueueUserData.
func (mr *MockTaskStoreMockRecorder) GetTaskQueueUserData(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueueUserData", reflect.TypeOf((*MockTaskStore)(nil).GetTaskQueueUserData), ctx, request)
}

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

// GetTaskQueuesByBuildId indicates an expected call of GetTaskQueuesByBuildId.
func (mr *MockTaskStoreMockRecorder) GetTaskQueuesByBuildId(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueuesByBuildId", reflect.TypeOf((*MockTaskStore)(nil).GetTaskQueuesByBuildId), ctx, request)
}

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

// GetTasks indicates an expected call of GetTasks.
func (mr *MockTaskStoreMockRecorder) GetTasks(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTasks", reflect.TypeOf((*MockTaskStore)(nil).GetTasks), ctx, request)
}

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

// ListTaskQueue indicates an expected call of ListTaskQueue.
func (mr *MockTaskStoreMockRecorder) ListTaskQueue(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).ListTaskQueue), ctx, request)
}

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

// ListTaskQueueUserDataEntries indicates an expected call of ListTaskQueueUserDataEntries.
func (mr *MockTaskStoreMockRecorder) ListTaskQueueUserDataEntries(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskQueueUserDataEntries", reflect.TypeOf((*MockTaskStore)(nil).ListTaskQueueUserDataEntries), ctx, request)
}

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

// UpdateTaskQueue indicates an expected call of UpdateTaskQueue.
func (mr *MockTaskStoreMockRecorder) UpdateTaskQueue(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).UpdateTaskQueue), ctx, request)
}

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

// UpdateTaskQueueUserData indicates an expected call of UpdateTaskQueueUserData.
func (mr *MockTaskStoreMockRecorder) UpdateTaskQueueUserData(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskQueueUserData", reflect.TypeOf((*MockTaskStore)(nil).UpdateTaskQueueUserData), ctx, request)
}

// MockMetadataStore is a mock of MetadataStore interface.
type MockMetadataStore struct {
	ctrl     *gomock.Controller
	recorder *MockMetadataStoreMockRecorder
}

// MockMetadataStoreMockRecorder is the mock recorder for MockMetadataStore.
type MockMetadataStoreMockRecorder struct {
	mock *MockMetadataStore
}

// NewMockMetadataStore creates a new mock instance.
func NewMockMetadataStore(ctrl *gomock.Controller) *MockMetadataStore {
	mock := &MockMetadataStore{ctrl: ctrl}
	mock.recorder = &MockMetadataStoreMockRecorder{mock}
	return mock
}

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

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

// Close indicates an expected call of 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))
}

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

// CreateNamespace indicates an expected call of CreateNamespace.
func (mr *MockMetadataStoreMockRecorder) CreateNamespace(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNamespace", reflect.TypeOf((*MockMetadataStore)(nil).CreateNamespace), ctx, request)
}

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

// DeleteNamespace indicates an expected call of DeleteNamespace.
func (mr *MockMetadataStoreMockRecorder) DeleteNamespace(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamespace", reflect.TypeOf((*MockMetadataStore)(nil).DeleteNamespace), ctx, request)
}

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

// DeleteNamespaceByName indicates an expected call of DeleteNamespaceByName.
func (mr *MockMetadataStoreMockRecorder) DeleteNamespaceByName(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamespaceByName", reflect.TypeOf((*MockMetadataStore)(nil).DeleteNamespaceByName), ctx, request)
}

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

// GetMetadata indicates an expected call of GetMetadata.
func (mr *MockMetadataStoreMockRecorder) GetMetadata(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockMetadataStore)(nil).GetMetadata), ctx)
}

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

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

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

// GetNamespace indicates an expected call of GetNamespace.
func (mr *MockMetadataStoreMockRecorder) GetNamespace(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespace", reflect.TypeOf((*MockMetadataStore)(nil).GetNamespace), ctx, request)
}

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

// ListNamespaces indicates an expected call of ListNamespaces.
func (mr *MockMetadataStoreMockRecorder) ListNamespaces(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNamespaces", reflect.TypeOf((*MockMetadataStore)(nil).ListNamespaces), ctx, request)
}

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

// RenameNamespace indicates an expected call of RenameNamespace.
func (mr *MockMetadataStoreMockRecorder) RenameNamespace(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNamespace", reflect.TypeOf((*MockMetadataStore)(nil).RenameNamespace), ctx, request)
}

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

// UpdateNamespace indicates an expected call of UpdateNamespace.
func (mr *MockMetadataStoreMockRecorder) UpdateNamespace(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNamespace", reflect.TypeOf((*MockMetadataStore)(nil).UpdateNamespace), ctx, request)
}

// MockClusterMetadataStore is a mock of ClusterMetadataStore interface.
type MockClusterMetadataStore struct {
	ctrl     *gomock.Controller
	recorder *MockClusterMetadataStoreMockRecorder
}

// MockClusterMetadataStoreMockRecorder is the mock recorder for MockClusterMetadataStore.
type MockClusterMetadataStoreMockRecorder struct {
	mock *MockClusterMetadataStore
}

// NewMockClusterMetadataStore creates a new mock instance.
func NewMockClusterMetadataStore(ctrl *gomock.Controller) *MockClusterMetadataStore {
	mock := &MockClusterMetadataStore{ctrl: ctrl}
	mock.recorder = &MockClusterMetadataStoreMockRecorder{mock}
	return mock
}

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

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

// Close indicates an expected call of 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))
}

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

// DeleteClusterMetadata indicates an expected call of DeleteClusterMetadata.
func (mr *MockClusterMetadataStoreMockRecorder) DeleteClusterMetadata(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClusterMetadata", reflect.TypeOf((*MockClusterMetadataStore)(nil).DeleteClusterMetadata), ctx, request)
}

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

// GetClusterMembers indicates an expected call of GetClusterMembers.
func (mr *MockClusterMetadataStoreMockRecorder) GetClusterMembers(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMembers", reflect.TypeOf((*MockClusterMetadataStore)(nil).GetClusterMembers), ctx, request)
}

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

// GetClusterMetadata indicates an expected call of GetClusterMetadata.
func (mr *MockClusterMetadataStoreMockRecorder) GetClusterMetadata(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMetadata", reflect.TypeOf((*MockClusterMetadataStore)(nil).GetClusterMetadata), ctx, request)
}

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

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

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

// ListClusterMetadata indicates an expected call of ListClusterMetadata.
func (mr *MockClusterMetadataStoreMockRecorder) ListClusterMetadata(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterMetadata", reflect.TypeOf((*MockClusterMetadataStore)(nil).ListClusterMetadata), ctx, request)
}

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

// PruneClusterMembership indicates an expected call of PruneClusterMembership.
func (mr *MockClusterMetadataStoreMockRecorder) PruneClusterMembership(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PruneClusterMembership", reflect.TypeOf((*MockClusterMetadataStore)(nil).PruneClusterMembership), ctx, request)
}

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

// SaveClusterMetadata indicates an expected call of SaveClusterMetadata.
func (mr *MockClusterMetadataStoreMockRecorder) SaveClusterMetadata(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveClusterMetadata", reflect.TypeOf((*MockClusterMetadataStore)(nil).SaveClusterMetadata), ctx, request)
}

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

// UpsertClusterMembership indicates an expected call of UpsertClusterMembership.
func (mr *MockClusterMetadataStoreMockRecorder) UpsertClusterMembership(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertClusterMembership", reflect.TypeOf((*MockClusterMetadataStore)(nil).UpsertClusterMembership), ctx, request)
}

// MockExecutionStore is a mock of ExecutionStore interface.
type MockExecutionStore struct {
	ctrl     *gomock.Controller
	recorder *MockExecutionStoreMockRecorder
}

// MockExecutionStoreMockRecorder is the mock recorder for MockExecutionStore.
type MockExecutionStoreMockRecorder struct {
	mock *MockExecutionStore
}

// NewMockExecutionStore creates a new mock instance.
func NewMockExecutionStore(ctrl *gomock.Controller) *MockExecutionStore {
	mock := &MockExecutionStore{ctrl: ctrl}
	mock.recorder = &MockExecutionStoreMockRecorder{mock}
	return mock
}

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

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

// AddHistoryTasks indicates an expected call of AddHistoryTasks.
func (mr *MockExecutionStoreMockRecorder) AddHistoryTasks(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHistoryTasks", reflect.TypeOf((*MockExecutionStore)(nil).AddHistoryTasks), ctx, request)
}

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

// AppendHistoryNodes indicates an expected call of AppendHistoryNodes.
func (mr *MockExecutionStoreMockRecorder) AppendHistoryNodes(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendHistoryNodes", reflect.TypeOf((*MockExecutionStore)(nil).AppendHistoryNodes), ctx, request)
}

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

// Close indicates an expected call of 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))
}

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

// CompleteHistoryTask indicates an expected call of CompleteHistoryTask.
func (mr *MockExecutionStoreMockRecorder) CompleteHistoryTask(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteHistoryTask", reflect.TypeOf((*MockExecutionStore)(nil).CompleteHistoryTask), ctx, request)
}

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

// ConflictResolveWorkflowExecution indicates an expected call of ConflictResolveWorkflowExecution.
func (mr *MockExecutionStoreMockRecorder) ConflictResolveWorkflowExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConflictResolveWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).ConflictResolveWorkflowExecution), ctx, request)
}

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

// CreateWorkflowExecution indicates an expected call of CreateWorkflowExecution.
func (mr *MockExecutionStoreMockRecorder) CreateWorkflowExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).CreateWorkflowExecution), ctx, request)
}

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

// DeleteCurrentWorkflowExecution indicates an expected call of DeleteCurrentWorkflowExecution.
func (mr *MockExecutionStoreMockRecorder) DeleteCurrentWorkflowExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCurrentWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).DeleteCurrentWorkflowExecution), ctx, request)
}

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

// DeleteHistoryBranch indicates an expected call of DeleteHistoryBranch.
func (mr *MockExecutionStoreMockRecorder) DeleteHistoryBranch(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHistoryBranch", reflect.TypeOf((*MockExecutionStore)(nil).DeleteHistoryBranch), ctx, request)
}

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

// DeleteHistoryNodes indicates an expected call of DeleteHistoryNodes.
func (mr *MockExecutionStoreMockRecorder) DeleteHistoryNodes(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHistoryNodes", reflect.TypeOf((*MockExecutionStore)(nil).DeleteHistoryNodes), ctx, request)
}

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

// DeleteReplicationTaskFromDLQ indicates an expected call of DeleteReplicationTaskFromDLQ.
func (mr *MockExecutionStoreMockRecorder) DeleteReplicationTaskFromDLQ(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationTaskFromDLQ", reflect.TypeOf((*MockExecutionStore)(nil).DeleteReplicationTaskFromDLQ), ctx, request)
}

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

// DeleteWorkflowExecution indicates an expected call of DeleteWorkflowExecution.
func (mr *MockExecutionStoreMockRecorder) DeleteWorkflowExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).DeleteWorkflowExecution), ctx, request)
}

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

// ForkHistoryBranch indicates an expected call of ForkHistoryBranch.
func (mr *MockExecutionStoreMockRecorder) ForkHistoryBranch(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForkHistoryBranch", reflect.TypeOf((*MockExecutionStore)(nil).ForkHistoryBranch), ctx, request)
}

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

// GetAllHistoryTreeBranches indicates an expected call of GetAllHistoryTreeBranches.
func (mr *MockExecutionStoreMockRecorder) GetAllHistoryTreeBranches(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllHistoryTreeBranches", reflect.TypeOf((*MockExecutionStore)(nil).GetAllHistoryTreeBranches), ctx, request)
}

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

// GetCurrentExecution indicates an expected call of GetCurrentExecution.
func (mr *MockExecutionStoreMockRecorder) GetCurrentExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentExecution", reflect.TypeOf((*MockExecutionStore)(nil).GetCurrentExecution), ctx, request)
}

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

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

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

// GetHistoryTasks indicates an expected call of GetHistoryTasks.
func (mr *MockExecutionStoreMockRecorder) GetHistoryTasks(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoryTasks", reflect.TypeOf((*MockExecutionStore)(nil).GetHistoryTasks), ctx, request)
}

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

// GetHistoryTree indicates an expected call of GetHistoryTree.
func (mr *MockExecutionStoreMockRecorder) GetHistoryTree(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoryTree", reflect.TypeOf((*MockExecutionStore)(nil).GetHistoryTree), ctx, request)
}

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

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

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

// GetReplicationTasksFromDLQ indicates an expected call of GetReplicationTasksFromDLQ.
func (mr *MockExecutionStoreMockRecorder) GetReplicationTasksFromDLQ(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReplicationTasksFromDLQ", reflect.TypeOf((*MockExecutionStore)(nil).GetReplicationTasksFromDLQ), ctx, request)
}

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

// GetWorkflowExecution indicates an expected call of GetWorkflowExecution.
func (mr *MockExecutionStoreMockRecorder) GetWorkflowExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).GetWorkflowExecution), ctx, request)
}

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

// IsReplicationDLQEmpty indicates an expected call of IsReplicationDLQEmpty.
func (mr *MockExecutionStoreMockRecorder) IsReplicationDLQEmpty(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsReplicationDLQEmpty", reflect.TypeOf((*MockExecutionStore)(nil).IsReplicationDLQEmpty), ctx, request)
}

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

// ListConcreteExecutions indicates an expected call of ListConcreteExecutions.
func (mr *MockExecutionStoreMockRecorder) ListConcreteExecutions(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConcreteExecutions", reflect.TypeOf((*MockExecutionStore)(nil).ListConcreteExecutions), ctx, request)
}

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

// PutReplicationTaskToDLQ indicates an expected call of PutReplicationTaskToDLQ.
func (mr *MockExecutionStoreMockRecorder) PutReplicationTaskToDLQ(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutReplicationTaskToDLQ", reflect.TypeOf((*MockExecutionStore)(nil).PutReplicationTaskToDLQ), ctx, request)
}

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

// RangeCompleteHistoryTasks indicates an expected call of RangeCompleteHistoryTasks.
func (mr *MockExecutionStoreMockRecorder) RangeCompleteHistoryTasks(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeCompleteHistoryTasks", reflect.TypeOf((*MockExecutionStore)(nil).RangeCompleteHistoryTasks), ctx, request)
}

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

// RangeDeleteReplicationTaskFromDLQ indicates an expected call of RangeDeleteReplicationTaskFromDLQ.
func (mr *MockExecutionStoreMockRecorder) RangeDeleteReplicationTaskFromDLQ(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteReplicationTaskFromDLQ", reflect.TypeOf((*MockExecutionStore)(nil).RangeDeleteReplicationTaskFromDLQ), ctx, request)
}

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

// ReadHistoryBranch indicates an expected call of ReadHistoryBranch.
func (mr *MockExecutionStoreMockRecorder) ReadHistoryBranch(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadHistoryBranch", reflect.TypeOf((*MockExecutionStore)(nil).ReadHistoryBranch), ctx, request)
}

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

// RegisterHistoryTaskReader indicates an expected call of RegisterHistoryTaskReader.
func (mr *MockExecutionStoreMockRecorder) RegisterHistoryTaskReader(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterHistoryTaskReader", reflect.TypeOf((*MockExecutionStore)(nil).RegisterHistoryTaskReader), ctx, request)
}

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

// SetWorkflowExecution indicates an expected call of SetWorkflowExecution.
func (mr *MockExecutionStoreMockRecorder) SetWorkflowExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).SetWorkflowExecution), ctx, request)
}

// UnregisterHistoryTaskReader mocks base method.
func (m *MockExecutionStore) UnregisterHistoryTaskReader(ctx context.Context, request *persistence.UnregisterHistoryTaskReaderRequest) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UnregisterHistoryTaskReader", ctx, request)
}

// UnregisterHistoryTaskReader indicates an expected call of UnregisterHistoryTaskReader.
func (mr *MockExecutionStoreMockRecorder) UnregisterHistoryTaskReader(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterHistoryTaskReader", reflect.TypeOf((*MockExecutionStore)(nil).UnregisterHistoryTaskReader), ctx, request)
}

// UpdateHistoryTaskReaderProgress mocks base method.
func (m *MockExecutionStore) UpdateHistoryTaskReaderProgress(ctx context.Context, request *persistence.UpdateHistoryTaskReaderProgressRequest) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateHistoryTaskReaderProgress", ctx, request)
}

// UpdateHistoryTaskReaderProgress indicates an expected call of UpdateHistoryTaskReaderProgress.
func (mr *MockExecutionStoreMockRecorder) UpdateHistoryTaskReaderProgress(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHistoryTaskReaderProgress", reflect.TypeOf((*MockExecutionStore)(nil).UpdateHistoryTaskReaderProgress), ctx, request)
}

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

// UpdateWorkflowExecution indicates an expected call of UpdateWorkflowExecution.
func (mr *MockExecutionStoreMockRecorder) UpdateWorkflowExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).UpdateWorkflowExecution), ctx, request)
}

// MockQueue is a mock of Queue interface.
type MockQueue struct {
	ctrl     *gomock.Controller
	recorder *MockQueueMockRecorder
}

// MockQueueMockRecorder is the mock recorder for MockQueue.
type MockQueueMockRecorder struct {
	mock *MockQueue
}

// NewMockQueue creates a new mock instance.
func NewMockQueue(ctrl *gomock.Controller) *MockQueue {
	mock := &MockQueue{ctrl: ctrl}
	mock.recorder = &MockQueueMockRecorder{mock}
	return mock
}

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

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

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

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

// DeleteMessageFromDLQ indicates an expected call of DeleteMessageFromDLQ.
func (mr *MockQueueMockRecorder) DeleteMessageFromDLQ(ctx, messageID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageFromDLQ", reflect.TypeOf((*MockQueue)(nil).DeleteMessageFromDLQ), ctx, messageID)
}

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

// DeleteMessagesBefore indicates an expected call of DeleteMessagesBefore.
func (mr *MockQueueMockRecorder) DeleteMessagesBefore(ctx, messageID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessagesBefore", reflect.TypeOf((*MockQueue)(nil).DeleteMessagesBefore), ctx, messageID)
}

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

// EnqueueMessage indicates an expected call of EnqueueMessage.
func (mr *MockQueueMockRecorder) EnqueueMessage(ctx, blob interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnqueueMessage", reflect.TypeOf((*MockQueue)(nil).EnqueueMessage), ctx, blob)
}

// EnqueueMessageToDLQ mocks base method.
func (m *MockQueue) EnqueueMessageToDLQ(ctx context.Context, blob *common.DataBlob) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnqueueMessageToDLQ", ctx, blob)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnqueueMessageToDLQ indicates an expected call of EnqueueMessageToDLQ.
func (mr *MockQueueMockRecorder) EnqueueMessageToDLQ(ctx, blob interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnqueueMessageToDLQ", reflect.TypeOf((*MockQueue)(nil).EnqueueMessageToDLQ), ctx, blob)
}

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

// GetAckLevels indicates an expected call of GetAckLevels.
func (mr *MockQueueMockRecorder) GetAckLevels(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAckLevels", reflect.TypeOf((*MockQueue)(nil).GetAckLevels), ctx)
}

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

// GetDLQAckLevels indicates an expected call of GetDLQAckLevels.
func (mr *MockQueueMockRecorder) GetDLQAckLevels(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDLQAckLevels", reflect.TypeOf((*MockQueue)(nil).GetDLQAckLevels), ctx)
}

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

// Init indicates an expected call of Init.
func (mr *MockQueueMockRecorder) Init(ctx, blob interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockQueue)(nil).Init), ctx, blob)
}

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

// RangeDeleteMessagesFromDLQ indicates an expected call of RangeDeleteMessagesFromDLQ.
func (mr *MockQueueMockRecorder) RangeDeleteMessagesFromDLQ(ctx, firstMessageID, lastMessageID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteMessagesFromDLQ", reflect.TypeOf((*MockQueue)(nil).RangeDeleteMessagesFromDLQ), ctx, firstMessageID, lastMessageID)
}

// ReadMessages mocks base method.
func (m *MockQueue) ReadMessages(ctx context.Context, lastMessageID int64, maxCount int) ([]*persistence.QueueMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadMessages", ctx, lastMessageID, maxCount)
	ret0, _ := ret[0].([]*persistence.QueueMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadMessages indicates an expected call of ReadMessages.
func (mr *MockQueueMockRecorder) ReadMessages(ctx, lastMessageID, maxCount interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadMessages", reflect.TypeOf((*MockQueue)(nil).ReadMessages), ctx, lastMessageID, maxCount)
}

// ReadMessagesFromDLQ mocks base method.
func (m *MockQueue) ReadMessagesFromDLQ(ctx context.Context, firstMessageID, lastMessageID int64, pageSize int, pageToken []byte) ([]*persistence.QueueMessage, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadMessagesFromDLQ", ctx, firstMessageID, lastMessageID, pageSize, pageToken)
	ret0, _ := ret[0].([]*persistence.QueueMessage)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReadMessagesFromDLQ indicates an expected call of ReadMessagesFromDLQ.
func (mr *MockQueueMockRecorder) ReadMessagesFromDLQ(ctx, firstMessageID, lastMessageID, pageSize, pageToken interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadMessagesFromDLQ", reflect.TypeOf((*MockQueue)(nil).ReadMessagesFromDLQ), ctx, firstMessageID, lastMessageID, pageSize, pageToken)
}

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

// UpdateAckLevel indicates an expected call of UpdateAckLevel.
func (mr *MockQueueMockRecorder) UpdateAckLevel(ctx, metadata interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAckLevel", reflect.TypeOf((*MockQueue)(nil).UpdateAckLevel), ctx, metadata)
}

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

// UpdateDLQAckLevel indicates an expected call of UpdateDLQAckLevel.
func (mr *MockQueueMockRecorder) UpdateDLQAckLevel(ctx, metadata interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDLQAckLevel", reflect.TypeOf((*MockQueue)(nil).UpdateDLQAckLevel), ctx, metadata)
}

// MockQueueV2 is a mock of QueueV2 interface.
type MockQueueV2 struct {
	ctrl     *gomock.Controller
	recorder *MockQueueV2MockRecorder
}

// MockQueueV2MockRecorder is the mock recorder for MockQueueV2.
type MockQueueV2MockRecorder struct {
	mock *MockQueueV2
}

// NewMockQueueV2 creates a new mock instance.
func NewMockQueueV2(ctrl *gomock.Controller) *MockQueueV2 {
	mock := &MockQueueV2{ctrl: ctrl}
	mock.recorder = &MockQueueV2MockRecorder{mock}
	return mock
}

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

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

// CreateQueue indicates an expected call of CreateQueue.
func (mr *MockQueueV2MockRecorder) CreateQueue(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueue", reflect.TypeOf((*MockQueueV2)(nil).CreateQueue), ctx, request)
}

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

// EnqueueMessage indicates an expected call of EnqueueMessage.
func (mr *MockQueueV2MockRecorder) EnqueueMessage(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnqueueMessage", reflect.TypeOf((*MockQueueV2)(nil).EnqueueMessage), ctx, request)
}

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

// ListQueues indicates an expected call of ListQueues.
func (mr *MockQueueV2MockRecorder) ListQueues(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueues", reflect.TypeOf((*MockQueueV2)(nil).ListQueues), ctx, request)
}

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

// RangeDeleteMessages indicates an expected call of RangeDeleteMessages.
func (mr *MockQueueV2MockRecorder) RangeDeleteMessages(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteMessages", reflect.TypeOf((*MockQueueV2)(nil).RangeDeleteMessages), ctx, request)
}

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

// ReadMessages indicates an expected call of ReadMessages.
func (mr *MockQueueV2MockRecorder) ReadMessages(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadMessages", reflect.TypeOf((*MockQueueV2)(nil).ReadMessages), ctx, request)
}