// Code generated by thriftrw-plugin-yarpc
// @generated

package adminservicetest

import (
	context "context"

	gomock "github.com/golang/mock/gomock"
	yarpc "go.uber.org/yarpc"

	admin "github.com/uber/cadence/.gen/go/admin"
	adminserviceclient "github.com/uber/cadence/.gen/go/admin/adminserviceclient"
	replicator "github.com/uber/cadence/.gen/go/replicator"
	shared "github.com/uber/cadence/.gen/go/shared"
)

// MockClient implements a gomock-compatible mock client for service
// AdminService.
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *_MockClientRecorder
}

var _ adminserviceclient.Interface = (*MockClient)(nil)

type _MockClientRecorder struct {
	mock *MockClient
}

// Build a new mock client for service AdminService.
//
//	mockCtrl := gomock.NewController(t)
//	client := adminservicetest.NewMockClient(mockCtrl)
//
// Use EXPECT() to set expectations on the mock.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &_MockClientRecorder{mock}
	return mock
}

// EXPECT returns an object that allows you to define an expectation on the
// AdminService mock client.
func (m *MockClient) EXPECT() *_MockClientRecorder {
	return m.recorder
}

// AddSearchAttribute responds to a AddSearchAttribute call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().AddSearchAttribute(gomock.Any(), ...).Return(...)
//	... := client.AddSearchAttribute(...)
func (m *MockClient) AddSearchAttribute(
	ctx context.Context,
	_Request *admin.AddSearchAttributeRequest,
	opts ...yarpc.CallOption,
) (err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "AddSearchAttribute", args...)
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) AddSearchAttribute(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "AddSearchAttribute", args...)
}

// CloseShard responds to a CloseShard call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().CloseShard(gomock.Any(), ...).Return(...)
//	... := client.CloseShard(...)
func (m *MockClient) CloseShard(
	ctx context.Context,
	_Request *shared.CloseShardRequest,
	opts ...yarpc.CallOption,
) (err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "CloseShard", args...)
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) CloseShard(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "CloseShard", args...)
}

// DeleteWorkflow responds to a DeleteWorkflow call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().DeleteWorkflow(gomock.Any(), ...).Return(...)
//	... := client.DeleteWorkflow(...)
func (m *MockClient) DeleteWorkflow(
	ctx context.Context,
	_Request *admin.AdminDeleteWorkflowRequest,
	opts ...yarpc.CallOption,
) (success *admin.AdminDeleteWorkflowResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "DeleteWorkflow", args...)
	success, _ = ret[i].(*admin.AdminDeleteWorkflowResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) DeleteWorkflow(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "DeleteWorkflow", args...)
}

// DescribeCluster responds to a DescribeCluster call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().DescribeCluster(gomock.Any(), ...).Return(...)
//	... := client.DescribeCluster(...)
func (m *MockClient) DescribeCluster(
	ctx context.Context,
	opts ...yarpc.CallOption,
) (success *admin.DescribeClusterResponse, err error) {

	args := []interface{}{ctx}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "DescribeCluster", args...)
	success, _ = ret[i].(*admin.DescribeClusterResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) DescribeCluster(
	ctx interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "DescribeCluster", args...)
}

// DescribeHistoryHost responds to a DescribeHistoryHost call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().DescribeHistoryHost(gomock.Any(), ...).Return(...)
//	... := client.DescribeHistoryHost(...)
func (m *MockClient) DescribeHistoryHost(
	ctx context.Context,
	_Request *shared.DescribeHistoryHostRequest,
	opts ...yarpc.CallOption,
) (success *shared.DescribeHistoryHostResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "DescribeHistoryHost", args...)
	success, _ = ret[i].(*shared.DescribeHistoryHostResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) DescribeHistoryHost(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "DescribeHistoryHost", args...)
}

// DescribeQueue responds to a DescribeQueue call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().DescribeQueue(gomock.Any(), ...).Return(...)
//	... := client.DescribeQueue(...)
func (m *MockClient) DescribeQueue(
	ctx context.Context,
	_Request *shared.DescribeQueueRequest,
	opts ...yarpc.CallOption,
) (success *shared.DescribeQueueResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "DescribeQueue", args...)
	success, _ = ret[i].(*shared.DescribeQueueResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) DescribeQueue(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "DescribeQueue", args...)
}

// DescribeShardDistribution responds to a DescribeShardDistribution call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().DescribeShardDistribution(gomock.Any(), ...).Return(...)
//	... := client.DescribeShardDistribution(...)
func (m *MockClient) DescribeShardDistribution(
	ctx context.Context,
	_Request *shared.DescribeShardDistributionRequest,
	opts ...yarpc.CallOption,
) (success *shared.DescribeShardDistributionResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "DescribeShardDistribution", args...)
	success, _ = ret[i].(*shared.DescribeShardDistributionResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) DescribeShardDistribution(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "DescribeShardDistribution", args...)
}

// DescribeWorkflowExecution responds to a DescribeWorkflowExecution call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().DescribeWorkflowExecution(gomock.Any(), ...).Return(...)
//	... := client.DescribeWorkflowExecution(...)
func (m *MockClient) DescribeWorkflowExecution(
	ctx context.Context,
	_Request *admin.DescribeWorkflowExecutionRequest,
	opts ...yarpc.CallOption,
) (success *admin.DescribeWorkflowExecutionResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "DescribeWorkflowExecution", args...)
	success, _ = ret[i].(*admin.DescribeWorkflowExecutionResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) DescribeWorkflowExecution(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "DescribeWorkflowExecution", args...)
}

// GetCrossClusterTasks responds to a GetCrossClusterTasks call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().GetCrossClusterTasks(gomock.Any(), ...).Return(...)
//	... := client.GetCrossClusterTasks(...)
func (m *MockClient) GetCrossClusterTasks(
	ctx context.Context,
	_Request *shared.GetCrossClusterTasksRequest,
	opts ...yarpc.CallOption,
) (success *shared.GetCrossClusterTasksResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "GetCrossClusterTasks", args...)
	success, _ = ret[i].(*shared.GetCrossClusterTasksResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) GetCrossClusterTasks(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "GetCrossClusterTasks", args...)
}

// GetDLQReplicationMessages responds to a GetDLQReplicationMessages call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().GetDLQReplicationMessages(gomock.Any(), ...).Return(...)
//	... := client.GetDLQReplicationMessages(...)
func (m *MockClient) GetDLQReplicationMessages(
	ctx context.Context,
	_Request *replicator.GetDLQReplicationMessagesRequest,
	opts ...yarpc.CallOption,
) (success *replicator.GetDLQReplicationMessagesResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "GetDLQReplicationMessages", args...)
	success, _ = ret[i].(*replicator.GetDLQReplicationMessagesResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) GetDLQReplicationMessages(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "GetDLQReplicationMessages", args...)
}

// GetDomainAsyncWorkflowConfiguraton responds to a GetDomainAsyncWorkflowConfiguraton call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().GetDomainAsyncWorkflowConfiguraton(gomock.Any(), ...).Return(...)
//	... := client.GetDomainAsyncWorkflowConfiguraton(...)
func (m *MockClient) GetDomainAsyncWorkflowConfiguraton(
	ctx context.Context,
	_Request *admin.GetDomainAsyncWorkflowConfiguratonRequest,
	opts ...yarpc.CallOption,
) (success *admin.GetDomainAsyncWorkflowConfiguratonResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "GetDomainAsyncWorkflowConfiguraton", args...)
	success, _ = ret[i].(*admin.GetDomainAsyncWorkflowConfiguratonResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) GetDomainAsyncWorkflowConfiguraton(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "GetDomainAsyncWorkflowConfiguraton", args...)
}

// GetDomainIsolationGroups responds to a GetDomainIsolationGroups call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().GetDomainIsolationGroups(gomock.Any(), ...).Return(...)
//	... := client.GetDomainIsolationGroups(...)
func (m *MockClient) GetDomainIsolationGroups(
	ctx context.Context,
	_Request *admin.GetDomainIsolationGroupsRequest,
	opts ...yarpc.CallOption,
) (success *admin.GetDomainIsolationGroupsResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "GetDomainIsolationGroups", args...)
	success, _ = ret[i].(*admin.GetDomainIsolationGroupsResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) GetDomainIsolationGroups(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "GetDomainIsolationGroups", args...)
}

// GetDomainReplicationMessages responds to a GetDomainReplicationMessages call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().GetDomainReplicationMessages(gomock.Any(), ...).Return(...)
//	... := client.GetDomainReplicationMessages(...)
func (m *MockClient) GetDomainReplicationMessages(
	ctx context.Context,
	_Request *replicator.GetDomainReplicationMessagesRequest,
	opts ...yarpc.CallOption,
) (success *replicator.GetDomainReplicationMessagesResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "GetDomainReplicationMessages", args...)
	success, _ = ret[i].(*replicator.GetDomainReplicationMessagesResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) GetDomainReplicationMessages(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "GetDomainReplicationMessages", args...)
}

// GetDynamicConfig responds to a GetDynamicConfig call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().GetDynamicConfig(gomock.Any(), ...).Return(...)
//	... := client.GetDynamicConfig(...)
func (m *MockClient) GetDynamicConfig(
	ctx context.Context,
	_Request *admin.GetDynamicConfigRequest,
	opts ...yarpc.CallOption,
) (success *admin.GetDynamicConfigResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "GetDynamicConfig", args...)
	success, _ = ret[i].(*admin.GetDynamicConfigResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) GetDynamicConfig(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "GetDynamicConfig", args...)
}

// GetGlobalIsolationGroups responds to a GetGlobalIsolationGroups call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().GetGlobalIsolationGroups(gomock.Any(), ...).Return(...)
//	... := client.GetGlobalIsolationGroups(...)
func (m *MockClient) GetGlobalIsolationGroups(
	ctx context.Context,
	_Request *admin.GetGlobalIsolationGroupsRequest,
	opts ...yarpc.CallOption,
) (success *admin.GetGlobalIsolationGroupsResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "GetGlobalIsolationGroups", args...)
	success, _ = ret[i].(*admin.GetGlobalIsolationGroupsResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) GetGlobalIsolationGroups(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "GetGlobalIsolationGroups", args...)
}

// GetReplicationMessages responds to a GetReplicationMessages call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().GetReplicationMessages(gomock.Any(), ...).Return(...)
//	... := client.GetReplicationMessages(...)
func (m *MockClient) GetReplicationMessages(
	ctx context.Context,
	_Request *replicator.GetReplicationMessagesRequest,
	opts ...yarpc.CallOption,
) (success *replicator.GetReplicationMessagesResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "GetReplicationMessages", args...)
	success, _ = ret[i].(*replicator.GetReplicationMessagesResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) GetReplicationMessages(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "GetReplicationMessages", args...)
}

// GetWorkflowExecutionRawHistoryV2 responds to a GetWorkflowExecutionRawHistoryV2 call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().GetWorkflowExecutionRawHistoryV2(gomock.Any(), ...).Return(...)
//	... := client.GetWorkflowExecutionRawHistoryV2(...)
func (m *MockClient) GetWorkflowExecutionRawHistoryV2(
	ctx context.Context,
	_GetRequest *admin.GetWorkflowExecutionRawHistoryV2Request,
	opts ...yarpc.CallOption,
) (success *admin.GetWorkflowExecutionRawHistoryV2Response, err error) {

	args := []interface{}{ctx, _GetRequest}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "GetWorkflowExecutionRawHistoryV2", args...)
	success, _ = ret[i].(*admin.GetWorkflowExecutionRawHistoryV2Response)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) GetWorkflowExecutionRawHistoryV2(
	ctx interface{},
	_GetRequest interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _GetRequest}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "GetWorkflowExecutionRawHistoryV2", args...)
}

// ListDynamicConfig responds to a ListDynamicConfig call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().ListDynamicConfig(gomock.Any(), ...).Return(...)
//	... := client.ListDynamicConfig(...)
func (m *MockClient) ListDynamicConfig(
	ctx context.Context,
	_Request *admin.ListDynamicConfigRequest,
	opts ...yarpc.CallOption,
) (success *admin.ListDynamicConfigResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "ListDynamicConfig", args...)
	success, _ = ret[i].(*admin.ListDynamicConfigResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) ListDynamicConfig(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "ListDynamicConfig", args...)
}

// MaintainCorruptWorkflow responds to a MaintainCorruptWorkflow call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().MaintainCorruptWorkflow(gomock.Any(), ...).Return(...)
//	... := client.MaintainCorruptWorkflow(...)
func (m *MockClient) MaintainCorruptWorkflow(
	ctx context.Context,
	_Request *admin.AdminMaintainWorkflowRequest,
	opts ...yarpc.CallOption,
) (success *admin.AdminMaintainWorkflowResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "MaintainCorruptWorkflow", args...)
	success, _ = ret[i].(*admin.AdminMaintainWorkflowResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) MaintainCorruptWorkflow(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "MaintainCorruptWorkflow", args...)
}

// MergeDLQMessages responds to a MergeDLQMessages call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().MergeDLQMessages(gomock.Any(), ...).Return(...)
//	... := client.MergeDLQMessages(...)
func (m *MockClient) MergeDLQMessages(
	ctx context.Context,
	_Request *replicator.MergeDLQMessagesRequest,
	opts ...yarpc.CallOption,
) (success *replicator.MergeDLQMessagesResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "MergeDLQMessages", args...)
	success, _ = ret[i].(*replicator.MergeDLQMessagesResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) MergeDLQMessages(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "MergeDLQMessages", args...)
}

// PurgeDLQMessages responds to a PurgeDLQMessages call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().PurgeDLQMessages(gomock.Any(), ...).Return(...)
//	... := client.PurgeDLQMessages(...)
func (m *MockClient) PurgeDLQMessages(
	ctx context.Context,
	_Request *replicator.PurgeDLQMessagesRequest,
	opts ...yarpc.CallOption,
) (err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "PurgeDLQMessages", args...)
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) PurgeDLQMessages(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "PurgeDLQMessages", args...)
}

// ReadDLQMessages responds to a ReadDLQMessages call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().ReadDLQMessages(gomock.Any(), ...).Return(...)
//	... := client.ReadDLQMessages(...)
func (m *MockClient) ReadDLQMessages(
	ctx context.Context,
	_Request *replicator.ReadDLQMessagesRequest,
	opts ...yarpc.CallOption,
) (success *replicator.ReadDLQMessagesResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "ReadDLQMessages", args...)
	success, _ = ret[i].(*replicator.ReadDLQMessagesResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) ReadDLQMessages(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "ReadDLQMessages", args...)
}

// ReapplyEvents responds to a ReapplyEvents call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().ReapplyEvents(gomock.Any(), ...).Return(...)
//	... := client.ReapplyEvents(...)
func (m *MockClient) ReapplyEvents(
	ctx context.Context,
	_ReapplyEventsRequest *shared.ReapplyEventsRequest,
	opts ...yarpc.CallOption,
) (err error) {

	args := []interface{}{ctx, _ReapplyEventsRequest}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "ReapplyEvents", args...)
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) ReapplyEvents(
	ctx interface{},
	_ReapplyEventsRequest interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _ReapplyEventsRequest}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "ReapplyEvents", args...)
}

// RefreshWorkflowTasks responds to a RefreshWorkflowTasks call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().RefreshWorkflowTasks(gomock.Any(), ...).Return(...)
//	... := client.RefreshWorkflowTasks(...)
func (m *MockClient) RefreshWorkflowTasks(
	ctx context.Context,
	_Request *shared.RefreshWorkflowTasksRequest,
	opts ...yarpc.CallOption,
) (err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "RefreshWorkflowTasks", args...)
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) RefreshWorkflowTasks(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "RefreshWorkflowTasks", args...)
}

// RemoveTask responds to a RemoveTask call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().RemoveTask(gomock.Any(), ...).Return(...)
//	... := client.RemoveTask(...)
func (m *MockClient) RemoveTask(
	ctx context.Context,
	_Request *shared.RemoveTaskRequest,
	opts ...yarpc.CallOption,
) (err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "RemoveTask", args...)
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) RemoveTask(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "RemoveTask", args...)
}

// ResendReplicationTasks responds to a ResendReplicationTasks call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().ResendReplicationTasks(gomock.Any(), ...).Return(...)
//	... := client.ResendReplicationTasks(...)
func (m *MockClient) ResendReplicationTasks(
	ctx context.Context,
	_Request *admin.ResendReplicationTasksRequest,
	opts ...yarpc.CallOption,
) (err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "ResendReplicationTasks", args...)
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) ResendReplicationTasks(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "ResendReplicationTasks", args...)
}

// ResetQueue responds to a ResetQueue call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().ResetQueue(gomock.Any(), ...).Return(...)
//	... := client.ResetQueue(...)
func (m *MockClient) ResetQueue(
	ctx context.Context,
	_Request *shared.ResetQueueRequest,
	opts ...yarpc.CallOption,
) (err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "ResetQueue", args...)
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) ResetQueue(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "ResetQueue", args...)
}

// RespondCrossClusterTasksCompleted responds to a RespondCrossClusterTasksCompleted call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().RespondCrossClusterTasksCompleted(gomock.Any(), ...).Return(...)
//	... := client.RespondCrossClusterTasksCompleted(...)
func (m *MockClient) RespondCrossClusterTasksCompleted(
	ctx context.Context,
	_Request *shared.RespondCrossClusterTasksCompletedRequest,
	opts ...yarpc.CallOption,
) (success *shared.RespondCrossClusterTasksCompletedResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "RespondCrossClusterTasksCompleted", args...)
	success, _ = ret[i].(*shared.RespondCrossClusterTasksCompletedResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) RespondCrossClusterTasksCompleted(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "RespondCrossClusterTasksCompleted", args...)
}

// RestoreDynamicConfig responds to a RestoreDynamicConfig call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().RestoreDynamicConfig(gomock.Any(), ...).Return(...)
//	... := client.RestoreDynamicConfig(...)
func (m *MockClient) RestoreDynamicConfig(
	ctx context.Context,
	_Request *admin.RestoreDynamicConfigRequest,
	opts ...yarpc.CallOption,
) (err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "RestoreDynamicConfig", args...)
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) RestoreDynamicConfig(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "RestoreDynamicConfig", args...)
}

// UpdateDomainAsyncWorkflowConfiguraton responds to a UpdateDomainAsyncWorkflowConfiguraton call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().UpdateDomainAsyncWorkflowConfiguraton(gomock.Any(), ...).Return(...)
//	... := client.UpdateDomainAsyncWorkflowConfiguraton(...)
func (m *MockClient) UpdateDomainAsyncWorkflowConfiguraton(
	ctx context.Context,
	_Request *admin.UpdateDomainAsyncWorkflowConfiguratonRequest,
	opts ...yarpc.CallOption,
) (success *admin.UpdateDomainAsyncWorkflowConfiguratonResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "UpdateDomainAsyncWorkflowConfiguraton", args...)
	success, _ = ret[i].(*admin.UpdateDomainAsyncWorkflowConfiguratonResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) UpdateDomainAsyncWorkflowConfiguraton(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "UpdateDomainAsyncWorkflowConfiguraton", args...)
}

// UpdateDomainIsolationGroups responds to a UpdateDomainIsolationGroups call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().UpdateDomainIsolationGroups(gomock.Any(), ...).Return(...)
//	... := client.UpdateDomainIsolationGroups(...)
func (m *MockClient) UpdateDomainIsolationGroups(
	ctx context.Context,
	_Request *admin.UpdateDomainIsolationGroupsRequest,
	opts ...yarpc.CallOption,
) (success *admin.UpdateDomainIsolationGroupsResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "UpdateDomainIsolationGroups", args...)
	success, _ = ret[i].(*admin.UpdateDomainIsolationGroupsResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) UpdateDomainIsolationGroups(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "UpdateDomainIsolationGroups", args...)
}

// UpdateDynamicConfig responds to a UpdateDynamicConfig call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().UpdateDynamicConfig(gomock.Any(), ...).Return(...)
//	... := client.UpdateDynamicConfig(...)
func (m *MockClient) UpdateDynamicConfig(
	ctx context.Context,
	_Request *admin.UpdateDynamicConfigRequest,
	opts ...yarpc.CallOption,
) (err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "UpdateDynamicConfig", args...)
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) UpdateDynamicConfig(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "UpdateDynamicConfig", args...)
}

// UpdateGlobalIsolationGroups responds to a UpdateGlobalIsolationGroups call based on the mock expectations. This
// call will fail if the mock does not expect this call. Use EXPECT to expect
// a call to this function.
//
//	client.EXPECT().UpdateGlobalIsolationGroups(gomock.Any(), ...).Return(...)
//	... := client.UpdateGlobalIsolationGroups(...)
func (m *MockClient) UpdateGlobalIsolationGroups(
	ctx context.Context,
	_Request *admin.UpdateGlobalIsolationGroupsRequest,
	opts ...yarpc.CallOption,
) (success *admin.UpdateGlobalIsolationGroupsResponse, err error) {

	args := []interface{}{ctx, _Request}
	for _, o := range opts {
		args = append(args, o)
	}
	i := 0
	ret := m.ctrl.Call(m, "UpdateGlobalIsolationGroups", args...)
	success, _ = ret[i].(*admin.UpdateGlobalIsolationGroupsResponse)
	i++
	err, _ = ret[i].(error)
	return
}

func (mr *_MockClientRecorder) UpdateGlobalIsolationGroups(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "UpdateGlobalIsolationGroups", args...)
}
