service/frontend/admin/interface_mock.go

// The MIT License (MIT)

// Copyright (c) 2017-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: interface.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"

	types "github.com/uber/cadence/common/types"
)

// MockHandler is a mock of Handler interface.
type MockHandler struct {
	ctrl     *gomock.Controller
	recorder *MockHandlerMockRecorder
}

// MockHandlerMockRecorder is the mock recorder for MockHandler.
type MockHandlerMockRecorder struct {
	mock *MockHandler
}

// NewMockHandler creates a new mock instance.
func NewMockHandler(ctrl *gomock.Controller) *MockHandler {
	mock := &MockHandler{ctrl: ctrl}
	mock.recorder = &MockHandlerMockRecorder{mock}
	return mock
}

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

// AddSearchAttribute mocks base method.
func (m *MockHandler) AddSearchAttribute(arg0 context.Context, arg1 *types.AddSearchAttributeRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSearchAttribute", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddSearchAttribute indicates an expected call of AddSearchAttribute.
func (mr *MockHandlerMockRecorder) AddSearchAttribute(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSearchAttribute", reflect.TypeOf((*MockHandler)(nil).AddSearchAttribute), arg0, arg1)
}

// CloseShard mocks base method.
func (m *MockHandler) CloseShard(arg0 context.Context, arg1 *types.CloseShardRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseShard", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseShard indicates an expected call of CloseShard.
func (mr *MockHandlerMockRecorder) CloseShard(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseShard", reflect.TypeOf((*MockHandler)(nil).CloseShard), arg0, arg1)
}

// CountDLQMessages mocks base method.
func (m *MockHandler) CountDLQMessages(arg0 context.Context, arg1 *types.CountDLQMessagesRequest) (*types.CountDLQMessagesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountDLQMessages", arg0, arg1)
	ret0, _ := ret[0].(*types.CountDLQMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountDLQMessages indicates an expected call of CountDLQMessages.
func (mr *MockHandlerMockRecorder) CountDLQMessages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountDLQMessages", reflect.TypeOf((*MockHandler)(nil).CountDLQMessages), arg0, arg1)
}

// DeleteWorkflow mocks base method.
func (m *MockHandler) DeleteWorkflow(arg0 context.Context, arg1 *types.AdminDeleteWorkflowRequest) (*types.AdminDeleteWorkflowResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkflow", arg0, arg1)
	ret0, _ := ret[0].(*types.AdminDeleteWorkflowResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteWorkflow indicates an expected call of DeleteWorkflow.
func (mr *MockHandlerMockRecorder) DeleteWorkflow(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkflow", reflect.TypeOf((*MockHandler)(nil).DeleteWorkflow), arg0, arg1)
}

// DescribeCluster mocks base method.
func (m *MockHandler) DescribeCluster(arg0 context.Context) (*types.DescribeClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCluster", arg0)
	ret0, _ := ret[0].(*types.DescribeClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCluster indicates an expected call of DescribeCluster.
func (mr *MockHandlerMockRecorder) DescribeCluster(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCluster", reflect.TypeOf((*MockHandler)(nil).DescribeCluster), arg0)
}

// DescribeHistoryHost mocks base method.
func (m *MockHandler) DescribeHistoryHost(arg0 context.Context, arg1 *types.DescribeHistoryHostRequest) (*types.DescribeHistoryHostResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHistoryHost", arg0, arg1)
	ret0, _ := ret[0].(*types.DescribeHistoryHostResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeHistoryHost indicates an expected call of DescribeHistoryHost.
func (mr *MockHandlerMockRecorder) DescribeHistoryHost(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHistoryHost", reflect.TypeOf((*MockHandler)(nil).DescribeHistoryHost), arg0, arg1)
}

// DescribeQueue mocks base method.
func (m *MockHandler) DescribeQueue(arg0 context.Context, arg1 *types.DescribeQueueRequest) (*types.DescribeQueueResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeQueue", arg0, arg1)
	ret0, _ := ret[0].(*types.DescribeQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeQueue indicates an expected call of DescribeQueue.
func (mr *MockHandlerMockRecorder) DescribeQueue(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeQueue", reflect.TypeOf((*MockHandler)(nil).DescribeQueue), arg0, arg1)
}

// DescribeShardDistribution mocks base method.
func (m *MockHandler) DescribeShardDistribution(arg0 context.Context, arg1 *types.DescribeShardDistributionRequest) (*types.DescribeShardDistributionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeShardDistribution", arg0, arg1)
	ret0, _ := ret[0].(*types.DescribeShardDistributionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeShardDistribution indicates an expected call of DescribeShardDistribution.
func (mr *MockHandlerMockRecorder) DescribeShardDistribution(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeShardDistribution", reflect.TypeOf((*MockHandler)(nil).DescribeShardDistribution), arg0, arg1)
}

// DescribeWorkflowExecution mocks base method.
func (m *MockHandler) DescribeWorkflowExecution(arg0 context.Context, arg1 *types.AdminDescribeWorkflowExecutionRequest) (*types.AdminDescribeWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeWorkflowExecution", arg0, arg1)
	ret0, _ := ret[0].(*types.AdminDescribeWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeWorkflowExecution indicates an expected call of DescribeWorkflowExecution.
func (mr *MockHandlerMockRecorder) DescribeWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeWorkflowExecution", reflect.TypeOf((*MockHandler)(nil).DescribeWorkflowExecution), arg0, arg1)
}

// GetCrossClusterTasks mocks base method.
func (m *MockHandler) GetCrossClusterTasks(arg0 context.Context, arg1 *types.GetCrossClusterTasksRequest) (*types.GetCrossClusterTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCrossClusterTasks", arg0, arg1)
	ret0, _ := ret[0].(*types.GetCrossClusterTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCrossClusterTasks indicates an expected call of GetCrossClusterTasks.
func (mr *MockHandlerMockRecorder) GetCrossClusterTasks(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCrossClusterTasks", reflect.TypeOf((*MockHandler)(nil).GetCrossClusterTasks), arg0, arg1)
}

// GetDLQReplicationMessages mocks base method.
func (m *MockHandler) GetDLQReplicationMessages(arg0 context.Context, arg1 *types.GetDLQReplicationMessagesRequest) (*types.GetDLQReplicationMessagesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDLQReplicationMessages", arg0, arg1)
	ret0, _ := ret[0].(*types.GetDLQReplicationMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDLQReplicationMessages indicates an expected call of GetDLQReplicationMessages.
func (mr *MockHandlerMockRecorder) GetDLQReplicationMessages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDLQReplicationMessages", reflect.TypeOf((*MockHandler)(nil).GetDLQReplicationMessages), arg0, arg1)
}

// GetDomainAsyncWorkflowConfiguraton mocks base method.
func (m *MockHandler) GetDomainAsyncWorkflowConfiguraton(arg0 context.Context, arg1 *types.GetDomainAsyncWorkflowConfiguratonRequest) (*types.GetDomainAsyncWorkflowConfiguratonResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDomainAsyncWorkflowConfiguraton", arg0, arg1)
	ret0, _ := ret[0].(*types.GetDomainAsyncWorkflowConfiguratonResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDomainAsyncWorkflowConfiguraton indicates an expected call of GetDomainAsyncWorkflowConfiguraton.
func (mr *MockHandlerMockRecorder) GetDomainAsyncWorkflowConfiguraton(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDomainAsyncWorkflowConfiguraton", reflect.TypeOf((*MockHandler)(nil).GetDomainAsyncWorkflowConfiguraton), arg0, arg1)
}

// GetDomainIsolationGroups mocks base method.
func (m *MockHandler) GetDomainIsolationGroups(ctx context.Context, request *types.GetDomainIsolationGroupsRequest) (*types.GetDomainIsolationGroupsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDomainIsolationGroups", ctx, request)
	ret0, _ := ret[0].(*types.GetDomainIsolationGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDomainReplicationMessages mocks base method.
func (m *MockHandler) GetDomainReplicationMessages(arg0 context.Context, arg1 *types.GetDomainReplicationMessagesRequest) (*types.GetDomainReplicationMessagesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDomainReplicationMessages", arg0, arg1)
	ret0, _ := ret[0].(*types.GetDomainReplicationMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDomainReplicationMessages indicates an expected call of GetDomainReplicationMessages.
func (mr *MockHandlerMockRecorder) GetDomainReplicationMessages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDomainReplicationMessages", reflect.TypeOf((*MockHandler)(nil).GetDomainReplicationMessages), arg0, arg1)
}

// GetDynamicConfig mocks base method.
func (m *MockHandler) GetDynamicConfig(arg0 context.Context, arg1 *types.GetDynamicConfigRequest) (*types.GetDynamicConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDynamicConfig", arg0, arg1)
	ret0, _ := ret[0].(*types.GetDynamicConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDynamicConfig indicates an expected call of GetDynamicConfig.
func (mr *MockHandlerMockRecorder) GetDynamicConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDynamicConfig", reflect.TypeOf((*MockHandler)(nil).GetDynamicConfig), arg0, arg1)
}

// GetGlobalIsolationGroups mocks base method.
func (m *MockHandler) GetGlobalIsolationGroups(ctx context.Context, request *types.GetGlobalIsolationGroupsRequest) (*types.GetGlobalIsolationGroupsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGlobalIsolationGroups", ctx, request)
	ret0, _ := ret[0].(*types.GetGlobalIsolationGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetReplicationMessages mocks base method.
func (m *MockHandler) GetReplicationMessages(arg0 context.Context, arg1 *types.GetReplicationMessagesRequest) (*types.GetReplicationMessagesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicationMessages", arg0, arg1)
	ret0, _ := ret[0].(*types.GetReplicationMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReplicationMessages indicates an expected call of GetReplicationMessages.
func (mr *MockHandlerMockRecorder) GetReplicationMessages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReplicationMessages", reflect.TypeOf((*MockHandler)(nil).GetReplicationMessages), arg0, arg1)
}

// GetWorkflowExecutionRawHistoryV2 mocks base method.
func (m *MockHandler) GetWorkflowExecutionRawHistoryV2(arg0 context.Context, arg1 *types.GetWorkflowExecutionRawHistoryV2Request) (*types.GetWorkflowExecutionRawHistoryV2Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflowExecutionRawHistoryV2", arg0, arg1)
	ret0, _ := ret[0].(*types.GetWorkflowExecutionRawHistoryV2Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkflowExecutionRawHistoryV2 indicates an expected call of GetWorkflowExecutionRawHistoryV2.
func (mr *MockHandlerMockRecorder) GetWorkflowExecutionRawHistoryV2(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowExecutionRawHistoryV2", reflect.TypeOf((*MockHandler)(nil).GetWorkflowExecutionRawHistoryV2), arg0, arg1)
}

// ListDynamicConfig mocks base method.
func (m *MockHandler) ListDynamicConfig(arg0 context.Context, arg1 *types.ListDynamicConfigRequest) (*types.ListDynamicConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDynamicConfig", arg0, arg1)
	ret0, _ := ret[0].(*types.ListDynamicConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDynamicConfig indicates an expected call of ListDynamicConfig.
func (mr *MockHandlerMockRecorder) ListDynamicConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDynamicConfig", reflect.TypeOf((*MockHandler)(nil).ListDynamicConfig), arg0, arg1)
}

// MaintainCorruptWorkflow mocks base method.
func (m *MockHandler) MaintainCorruptWorkflow(arg0 context.Context, arg1 *types.AdminMaintainWorkflowRequest) (*types.AdminMaintainWorkflowResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MaintainCorruptWorkflow", arg0, arg1)
	ret0, _ := ret[0].(*types.AdminMaintainWorkflowResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MaintainCorruptWorkflow indicates an expected call of MaintainCorruptWorkflow.
func (mr *MockHandlerMockRecorder) MaintainCorruptWorkflow(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaintainCorruptWorkflow", reflect.TypeOf((*MockHandler)(nil).MaintainCorruptWorkflow), arg0, arg1)
}

// MergeDLQMessages mocks base method.
func (m *MockHandler) MergeDLQMessages(arg0 context.Context, arg1 *types.MergeDLQMessagesRequest) (*types.MergeDLQMessagesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MergeDLQMessages", arg0, arg1)
	ret0, _ := ret[0].(*types.MergeDLQMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MergeDLQMessages indicates an expected call of MergeDLQMessages.
func (mr *MockHandlerMockRecorder) MergeDLQMessages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MergeDLQMessages", reflect.TypeOf((*MockHandler)(nil).MergeDLQMessages), arg0, arg1)
}

// PurgeDLQMessages mocks base method.
func (m *MockHandler) PurgeDLQMessages(arg0 context.Context, arg1 *types.PurgeDLQMessagesRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PurgeDLQMessages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// PurgeDLQMessages indicates an expected call of PurgeDLQMessages.
func (mr *MockHandlerMockRecorder) PurgeDLQMessages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeDLQMessages", reflect.TypeOf((*MockHandler)(nil).PurgeDLQMessages), arg0, arg1)
}

// ReadDLQMessages mocks base method.
func (m *MockHandler) ReadDLQMessages(arg0 context.Context, arg1 *types.ReadDLQMessagesRequest) (*types.ReadDLQMessagesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadDLQMessages", arg0, arg1)
	ret0, _ := ret[0].(*types.ReadDLQMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadDLQMessages indicates an expected call of ReadDLQMessages.
func (mr *MockHandlerMockRecorder) ReadDLQMessages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadDLQMessages", reflect.TypeOf((*MockHandler)(nil).ReadDLQMessages), arg0, arg1)
}

// ReapplyEvents mocks base method.
func (m *MockHandler) ReapplyEvents(arg0 context.Context, arg1 *types.ReapplyEventsRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReapplyEvents", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReapplyEvents indicates an expected call of ReapplyEvents.
func (mr *MockHandlerMockRecorder) ReapplyEvents(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReapplyEvents", reflect.TypeOf((*MockHandler)(nil).ReapplyEvents), arg0, arg1)
}

// RefreshWorkflowTasks mocks base method.
func (m *MockHandler) RefreshWorkflowTasks(arg0 context.Context, arg1 *types.RefreshWorkflowTasksRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RefreshWorkflowTasks", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// RefreshWorkflowTasks indicates an expected call of RefreshWorkflowTasks.
func (mr *MockHandlerMockRecorder) RefreshWorkflowTasks(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshWorkflowTasks", reflect.TypeOf((*MockHandler)(nil).RefreshWorkflowTasks), arg0, arg1)
}

// RemoveTask mocks base method.
func (m *MockHandler) RemoveTask(arg0 context.Context, arg1 *types.RemoveTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveTask", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveTask indicates an expected call of RemoveTask.
func (mr *MockHandlerMockRecorder) RemoveTask(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTask", reflect.TypeOf((*MockHandler)(nil).RemoveTask), arg0, arg1)
}

// ResendReplicationTasks mocks base method.
func (m *MockHandler) ResendReplicationTasks(arg0 context.Context, arg1 *types.ResendReplicationTasksRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResendReplicationTasks", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResendReplicationTasks indicates an expected call of ResendReplicationTasks.
func (mr *MockHandlerMockRecorder) ResendReplicationTasks(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendReplicationTasks", reflect.TypeOf((*MockHandler)(nil).ResendReplicationTasks), arg0, arg1)
}

// ResetQueue mocks base method.
func (m *MockHandler) ResetQueue(arg0 context.Context, arg1 *types.ResetQueueRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetQueue", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResetQueue indicates an expected call of ResetQueue.
func (mr *MockHandlerMockRecorder) ResetQueue(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetQueue", reflect.TypeOf((*MockHandler)(nil).ResetQueue), arg0, arg1)
}

// RespondCrossClusterTasksCompleted mocks base method.
func (m *MockHandler) RespondCrossClusterTasksCompleted(arg0 context.Context, arg1 *types.RespondCrossClusterTasksCompletedRequest) (*types.RespondCrossClusterTasksCompletedResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RespondCrossClusterTasksCompleted", arg0, arg1)
	ret0, _ := ret[0].(*types.RespondCrossClusterTasksCompletedResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RespondCrossClusterTasksCompleted indicates an expected call of RespondCrossClusterTasksCompleted.
func (mr *MockHandlerMockRecorder) RespondCrossClusterTasksCompleted(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondCrossClusterTasksCompleted", reflect.TypeOf((*MockHandler)(nil).RespondCrossClusterTasksCompleted), arg0, arg1)
}

// RestoreDynamicConfig mocks base method.
func (m *MockHandler) RestoreDynamicConfig(arg0 context.Context, arg1 *types.RestoreDynamicConfigRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreDynamicConfig", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// RestoreDynamicConfig indicates an expected call of RestoreDynamicConfig.
func (mr *MockHandlerMockRecorder) RestoreDynamicConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDynamicConfig", reflect.TypeOf((*MockHandler)(nil).RestoreDynamicConfig), arg0, arg1)
}

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

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

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

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

// UpdateDomainAsyncWorkflowConfiguraton mocks base method.
func (m *MockHandler) UpdateDomainAsyncWorkflowConfiguraton(arg0 context.Context, arg1 *types.UpdateDomainAsyncWorkflowConfiguratonRequest) (*types.UpdateDomainAsyncWorkflowConfiguratonResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDomainAsyncWorkflowConfiguraton", arg0, arg1)
	ret0, _ := ret[0].(*types.UpdateDomainAsyncWorkflowConfiguratonResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDomainAsyncWorkflowConfiguraton indicates an expected call of UpdateDomainAsyncWorkflowConfiguraton.
func (mr *MockHandlerMockRecorder) UpdateDomainAsyncWorkflowConfiguraton(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDomainAsyncWorkflowConfiguraton", reflect.TypeOf((*MockHandler)(nil).UpdateDomainAsyncWorkflowConfiguraton), arg0, arg1)
}

// UpdateDomainIsolationGroups mocks base method.
func (m *MockHandler) UpdateDomainIsolationGroups(ctx context.Context, request *types.UpdateDomainIsolationGroupsRequest) (*types.UpdateDomainIsolationGroupsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDomainIsolationGroups", ctx, request)
	ret0, _ := ret[0].(*types.UpdateDomainIsolationGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDynamicConfig mocks base method.
func (m *MockHandler) UpdateDynamicConfig(arg0 context.Context, arg1 *types.UpdateDynamicConfigRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDynamicConfig", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDynamicConfig indicates an expected call of UpdateDynamicConfig.
func (mr *MockHandlerMockRecorder) UpdateDynamicConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDynamicConfig", reflect.TypeOf((*MockHandler)(nil).UpdateDynamicConfig), arg0, arg1)
}

// UpdateGlobalIsolationGroups mocks base method.
func (m *MockHandler) UpdateGlobalIsolationGroups(ctx context.Context, request *types.UpdateGlobalIsolationGroupsRequest) (*types.UpdateGlobalIsolationGroupsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGlobalIsolationGroups", ctx, request)
	ret0, _ := ret[0].(*types.UpdateGlobalIsolationGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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