tasks/service/frontend/interface_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: interface.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	v1 "go.temporal.io/api/operatorservice/v1"
	v10 "go.temporal.io/api/workflowservice/v1"
)

// 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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DescribeWorkflowExecution mocks base method.
func (m *MockHandler) DescribeWorkflowExecution(arg0 context.Context, arg1 *v10.DescribeWorkflowExecutionRequest) (*v10.DescribeWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeWorkflowExecution", arg0, arg1)
	ret0, _ := ret[0].(*v10.DescribeWorkflowExecutionResponse)
	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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SignalWorkflowExecution indicates an expected call of SignalWorkflowExecution.
func (mr *MockHandlerMockRecorder) SignalWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalWorkflowExecution", reflect.TypeOf((*MockHandler)(nil).SignalWorkflowExecution), 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))
}

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

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

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

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

// 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))
}

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

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

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

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

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

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

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

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

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

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

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

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

// MockOperatorHandler is a mock of OperatorHandler interface.
type MockOperatorHandler struct {
	ctrl     *gomock.Controller
	recorder *MockOperatorHandlerMockRecorder
}

// MockOperatorHandlerMockRecorder is the mock recorder for MockOperatorHandler.
type MockOperatorHandlerMockRecorder struct {
	mock *MockOperatorHandler
}

// NewMockOperatorHandler creates a new mock instance.
func NewMockOperatorHandler(ctrl *gomock.Controller) *MockOperatorHandler {
	mock := &MockOperatorHandler{ctrl: ctrl}
	mock.recorder = &MockOperatorHandlerMockRecorder{mock}
	return mock
}

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

// AddOrUpdateRemoteCluster mocks base method.
func (m *MockOperatorHandler) AddOrUpdateRemoteCluster(arg0 context.Context, arg1 *v1.AddOrUpdateRemoteClusterRequest) (*v1.AddOrUpdateRemoteClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddOrUpdateRemoteCluster", arg0, arg1)
	ret0, _ := ret[0].(*v1.AddOrUpdateRemoteClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddSearchAttributes mocks base method.
func (m *MockOperatorHandler) AddSearchAttributes(arg0 context.Context, arg1 *v1.AddSearchAttributesRequest) (*v1.AddSearchAttributesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSearchAttributes", arg0, arg1)
	ret0, _ := ret[0].(*v1.AddSearchAttributesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNamespace mocks base method.
func (m *MockOperatorHandler) DeleteNamespace(arg0 context.Context, arg1 *v1.DeleteNamespaceRequest) (*v1.DeleteNamespaceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNamespace", arg0, arg1)
	ret0, _ := ret[0].(*v1.DeleteNamespaceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListClusters mocks base method.
func (m *MockOperatorHandler) ListClusters(arg0 context.Context, arg1 *v1.ListClustersRequest) (*v1.ListClustersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusters", arg0, arg1)
	ret0, _ := ret[0].(*v1.ListClustersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListSearchAttributes mocks base method.
func (m *MockOperatorHandler) ListSearchAttributes(arg0 context.Context, arg1 *v1.ListSearchAttributesRequest) (*v1.ListSearchAttributesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSearchAttributes", arg0, arg1)
	ret0, _ := ret[0].(*v1.ListSearchAttributesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveRemoteCluster mocks base method.
func (m *MockOperatorHandler) RemoveRemoteCluster(arg0 context.Context, arg1 *v1.RemoveRemoteClusterRequest) (*v1.RemoveRemoteClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveRemoteCluster", arg0, arg1)
	ret0, _ := ret[0].(*v1.RemoveRemoteClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveSearchAttributes mocks base method.
func (m *MockOperatorHandler) RemoveSearchAttributes(arg0 context.Context, arg1 *v1.RemoveSearchAttributesRequest) (*v1.RemoveSearchAttributesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveSearchAttributes", arg0, arg1)
	ret0, _ := ret[0].(*v1.RemoveSearchAttributesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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