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

package workflowservicetest

import (
	context "context"

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

	workflowserviceclient "github.com/uber/cadence/.gen/go/cadence/workflowserviceclient"
	shared "github.com/uber/cadence/.gen/go/shared"
)

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

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

type _MockClientRecorder struct {
	mock *MockClient
}

// Build a new mock client for service WorkflowService.
//
//	mockCtrl := gomock.NewController(t)
//	client := workflowservicetest.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
// WorkflowService mock client.
func (m *MockClient) EXPECT() *_MockClientRecorder {
	return m.recorder
}

// CountWorkflowExecutions responds to a CountWorkflowExecutions 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().CountWorkflowExecutions(gomock.Any(), ...).Return(...)
//	... := client.CountWorkflowExecutions(...)
func (m *MockClient) CountWorkflowExecutions(
	ctx context.Context,
	_CountRequest *shared.CountWorkflowExecutionsRequest,
	opts ...yarpc.CallOption,
) (success *shared.CountWorkflowExecutionsResponse, err error) {

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

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

// DeleteDomain responds to a DeleteDomain 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().DeleteDomain(gomock.Any(), ...).Return(...)
//	... := client.DeleteDomain(...)
func (m *MockClient) DeleteDomain(
	ctx context.Context,
	_DeleteRequest *shared.DeleteDomainRequest,
	opts ...yarpc.CallOption,
) (err error) {

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

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

// DeprecateDomain responds to a DeprecateDomain 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().DeprecateDomain(gomock.Any(), ...).Return(...)
//	... := client.DeprecateDomain(...)
func (m *MockClient) DeprecateDomain(
	ctx context.Context,
	_DeprecateRequest *shared.DeprecateDomainRequest,
	opts ...yarpc.CallOption,
) (err error) {

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

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

// DescribeDomain responds to a DescribeDomain 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().DescribeDomain(gomock.Any(), ...).Return(...)
//	... := client.DescribeDomain(...)
func (m *MockClient) DescribeDomain(
	ctx context.Context,
	_DescribeRequest *shared.DescribeDomainRequest,
	opts ...yarpc.CallOption,
) (success *shared.DescribeDomainResponse, err error) {

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

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

// DescribeTaskList responds to a DescribeTaskList 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().DescribeTaskList(gomock.Any(), ...).Return(...)
//	... := client.DescribeTaskList(...)
func (m *MockClient) DescribeTaskList(
	ctx context.Context,
	_Request *shared.DescribeTaskListRequest,
	opts ...yarpc.CallOption,
) (success *shared.DescribeTaskListResponse, err error) {

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

func (mr *_MockClientRecorder) DescribeTaskList(
	ctx interface{},
	_Request interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _Request}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "DescribeTaskList", 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,
	_DescribeRequest *shared.DescribeWorkflowExecutionRequest,
	opts ...yarpc.CallOption,
) (success *shared.DescribeWorkflowExecutionResponse, err error) {

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

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

// DiagnoseWorkflowExecution responds to a DiagnoseWorkflowExecution 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().DiagnoseWorkflowExecution(gomock.Any(), ...).Return(...)
//	... := client.DiagnoseWorkflowExecution(...)
func (m *MockClient) DiagnoseWorkflowExecution(
	ctx context.Context,
	_DiagnoseRequest *shared.DiagnoseWorkflowExecutionRequest,
	opts ...yarpc.CallOption,
) (success *shared.DiagnoseWorkflowExecutionResponse, err error) {

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

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

// FailoverDomain responds to a FailoverDomain 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().FailoverDomain(gomock.Any(), ...).Return(...)
//	... := client.FailoverDomain(...)
func (m *MockClient) FailoverDomain(
	ctx context.Context,
	_FailoverRequest *shared.FailoverDomainRequest,
	opts ...yarpc.CallOption,
) (success *shared.FailoverDomainResponse, err error) {

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

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

// GetClusterInfo responds to a GetClusterInfo 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().GetClusterInfo(gomock.Any(), ...).Return(...)
//	... := client.GetClusterInfo(...)
func (m *MockClient) GetClusterInfo(
	ctx context.Context,
	opts ...yarpc.CallOption,
) (success *shared.ClusterInfo, err error) {

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

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

// GetSearchAttributes responds to a GetSearchAttributes 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().GetSearchAttributes(gomock.Any(), ...).Return(...)
//	... := client.GetSearchAttributes(...)
func (m *MockClient) GetSearchAttributes(
	ctx context.Context,
	opts ...yarpc.CallOption,
) (success *shared.GetSearchAttributesResponse, err error) {

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

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

// GetTaskListsByDomain responds to a GetTaskListsByDomain 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().GetTaskListsByDomain(gomock.Any(), ...).Return(...)
//	... := client.GetTaskListsByDomain(...)
func (m *MockClient) GetTaskListsByDomain(
	ctx context.Context,
	_Request *shared.GetTaskListsByDomainRequest,
	opts ...yarpc.CallOption,
) (success *shared.GetTaskListsByDomainResponse, err error) {

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

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

// GetWorkflowExecutionHistory responds to a GetWorkflowExecutionHistory 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().GetWorkflowExecutionHistory(gomock.Any(), ...).Return(...)
//	... := client.GetWorkflowExecutionHistory(...)
func (m *MockClient) GetWorkflowExecutionHistory(
	ctx context.Context,
	_GetRequest *shared.GetWorkflowExecutionHistoryRequest,
	opts ...yarpc.CallOption,
) (success *shared.GetWorkflowExecutionHistoryResponse, err error) {

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

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

// ListArchivedWorkflowExecutions responds to a ListArchivedWorkflowExecutions 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().ListArchivedWorkflowExecutions(gomock.Any(), ...).Return(...)
//	... := client.ListArchivedWorkflowExecutions(...)
func (m *MockClient) ListArchivedWorkflowExecutions(
	ctx context.Context,
	_ListRequest *shared.ListArchivedWorkflowExecutionsRequest,
	opts ...yarpc.CallOption,
) (success *shared.ListArchivedWorkflowExecutionsResponse, err error) {

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

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

// ListClosedWorkflowExecutions responds to a ListClosedWorkflowExecutions 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().ListClosedWorkflowExecutions(gomock.Any(), ...).Return(...)
//	... := client.ListClosedWorkflowExecutions(...)
func (m *MockClient) ListClosedWorkflowExecutions(
	ctx context.Context,
	_ListRequest *shared.ListClosedWorkflowExecutionsRequest,
	opts ...yarpc.CallOption,
) (success *shared.ListClosedWorkflowExecutionsResponse, err error) {

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

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

// ListDomains responds to a ListDomains 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().ListDomains(gomock.Any(), ...).Return(...)
//	... := client.ListDomains(...)
func (m *MockClient) ListDomains(
	ctx context.Context,
	_ListRequest *shared.ListDomainsRequest,
	opts ...yarpc.CallOption,
) (success *shared.ListDomainsResponse, err error) {

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

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

// ListOpenWorkflowExecutions responds to a ListOpenWorkflowExecutions 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().ListOpenWorkflowExecutions(gomock.Any(), ...).Return(...)
//	... := client.ListOpenWorkflowExecutions(...)
func (m *MockClient) ListOpenWorkflowExecutions(
	ctx context.Context,
	_ListRequest *shared.ListOpenWorkflowExecutionsRequest,
	opts ...yarpc.CallOption,
) (success *shared.ListOpenWorkflowExecutionsResponse, err error) {

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

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

// ListTaskListPartitions responds to a ListTaskListPartitions 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().ListTaskListPartitions(gomock.Any(), ...).Return(...)
//	... := client.ListTaskListPartitions(...)
func (m *MockClient) ListTaskListPartitions(
	ctx context.Context,
	_Request *shared.ListTaskListPartitionsRequest,
	opts ...yarpc.CallOption,
) (success *shared.ListTaskListPartitionsResponse, err error) {

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

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

// ListWorkflowExecutions responds to a ListWorkflowExecutions 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().ListWorkflowExecutions(gomock.Any(), ...).Return(...)
//	... := client.ListWorkflowExecutions(...)
func (m *MockClient) ListWorkflowExecutions(
	ctx context.Context,
	_ListRequest *shared.ListWorkflowExecutionsRequest,
	opts ...yarpc.CallOption,
) (success *shared.ListWorkflowExecutionsResponse, err error) {

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

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

// PollForActivityTask responds to a PollForActivityTask 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().PollForActivityTask(gomock.Any(), ...).Return(...)
//	... := client.PollForActivityTask(...)
func (m *MockClient) PollForActivityTask(
	ctx context.Context,
	_PollRequest *shared.PollForActivityTaskRequest,
	opts ...yarpc.CallOption,
) (success *shared.PollForActivityTaskResponse, err error) {

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

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

// PollForDecisionTask responds to a PollForDecisionTask 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().PollForDecisionTask(gomock.Any(), ...).Return(...)
//	... := client.PollForDecisionTask(...)
func (m *MockClient) PollForDecisionTask(
	ctx context.Context,
	_PollRequest *shared.PollForDecisionTaskRequest,
	opts ...yarpc.CallOption,
) (success *shared.PollForDecisionTaskResponse, err error) {

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

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

// QueryWorkflow responds to a QueryWorkflow 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().QueryWorkflow(gomock.Any(), ...).Return(...)
//	... := client.QueryWorkflow(...)
func (m *MockClient) QueryWorkflow(
	ctx context.Context,
	_QueryRequest *shared.QueryWorkflowRequest,
	opts ...yarpc.CallOption,
) (success *shared.QueryWorkflowResponse, err error) {

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

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

// RecordActivityTaskHeartbeat responds to a RecordActivityTaskHeartbeat 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().RecordActivityTaskHeartbeat(gomock.Any(), ...).Return(...)
//	... := client.RecordActivityTaskHeartbeat(...)
func (m *MockClient) RecordActivityTaskHeartbeat(
	ctx context.Context,
	_HeartbeatRequest *shared.RecordActivityTaskHeartbeatRequest,
	opts ...yarpc.CallOption,
) (success *shared.RecordActivityTaskHeartbeatResponse, err error) {

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

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

// RecordActivityTaskHeartbeatByID responds to a RecordActivityTaskHeartbeatByID 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().RecordActivityTaskHeartbeatByID(gomock.Any(), ...).Return(...)
//	... := client.RecordActivityTaskHeartbeatByID(...)
func (m *MockClient) RecordActivityTaskHeartbeatByID(
	ctx context.Context,
	_HeartbeatRequest *shared.RecordActivityTaskHeartbeatByIDRequest,
	opts ...yarpc.CallOption,
) (success *shared.RecordActivityTaskHeartbeatResponse, err error) {

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

func (mr *_MockClientRecorder) RecordActivityTaskHeartbeatByID(
	ctx interface{},
	_HeartbeatRequest interface{},
	opts ...interface{},
) *gomock.Call {
	args := append([]interface{}{ctx, _HeartbeatRequest}, opts...)
	return mr.mock.ctrl.RecordCall(mr.mock, "RecordActivityTaskHeartbeatByID", 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...)
}

// RegisterDomain responds to a RegisterDomain 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().RegisterDomain(gomock.Any(), ...).Return(...)
//	... := client.RegisterDomain(...)
func (m *MockClient) RegisterDomain(
	ctx context.Context,
	_RegisterRequest *shared.RegisterDomainRequest,
	opts ...yarpc.CallOption,
) (err error) {

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

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

// RequestCancelWorkflowExecution responds to a RequestCancelWorkflowExecution 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().RequestCancelWorkflowExecution(gomock.Any(), ...).Return(...)
//	... := client.RequestCancelWorkflowExecution(...)
func (m *MockClient) RequestCancelWorkflowExecution(
	ctx context.Context,
	_CancelRequest *shared.RequestCancelWorkflowExecutionRequest,
	opts ...yarpc.CallOption,
) (err error) {

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

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

// ResetStickyTaskList responds to a ResetStickyTaskList 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().ResetStickyTaskList(gomock.Any(), ...).Return(...)
//	... := client.ResetStickyTaskList(...)
func (m *MockClient) ResetStickyTaskList(
	ctx context.Context,
	_ResetRequest *shared.ResetStickyTaskListRequest,
	opts ...yarpc.CallOption,
) (success *shared.ResetStickyTaskListResponse, err error) {

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

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

// ResetWorkflowExecution responds to a ResetWorkflowExecution 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().ResetWorkflowExecution(gomock.Any(), ...).Return(...)
//	... := client.ResetWorkflowExecution(...)
func (m *MockClient) ResetWorkflowExecution(
	ctx context.Context,
	_ResetRequest *shared.ResetWorkflowExecutionRequest,
	opts ...yarpc.CallOption,
) (success *shared.ResetWorkflowExecutionResponse, err error) {

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

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

// RespondActivityTaskCanceled responds to a RespondActivityTaskCanceled 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().RespondActivityTaskCanceled(gomock.Any(), ...).Return(...)
//	... := client.RespondActivityTaskCanceled(...)
func (m *MockClient) RespondActivityTaskCanceled(
	ctx context.Context,
	_CanceledRequest *shared.RespondActivityTaskCanceledRequest,
	opts ...yarpc.CallOption,
) (err error) {

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

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

// RespondActivityTaskCanceledByID responds to a RespondActivityTaskCanceledByID 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().RespondActivityTaskCanceledByID(gomock.Any(), ...).Return(...)
//	... := client.RespondActivityTaskCanceledByID(...)
func (m *MockClient) RespondActivityTaskCanceledByID(
	ctx context.Context,
	_CanceledRequest *shared.RespondActivityTaskCanceledByIDRequest,
	opts ...yarpc.CallOption,
) (err error) {

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

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

// RespondActivityTaskCompleted responds to a RespondActivityTaskCompleted 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().RespondActivityTaskCompleted(gomock.Any(), ...).Return(...)
//	... := client.RespondActivityTaskCompleted(...)
func (m *MockClient) RespondActivityTaskCompleted(
	ctx context.Context,
	_CompleteRequest *shared.RespondActivityTaskCompletedRequest,
	opts ...yarpc.CallOption,
) (err error) {

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

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

// RespondActivityTaskCompletedByID responds to a RespondActivityTaskCompletedByID 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().RespondActivityTaskCompletedByID(gomock.Any(), ...).Return(...)
//	... := client.RespondActivityTaskCompletedByID(...)
func (m *MockClient) RespondActivityTaskCompletedByID(
	ctx context.Context,
	_CompleteRequest *shared.RespondActivityTaskCompletedByIDRequest,
	opts ...yarpc.CallOption,
) (err error) {

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

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

// RespondActivityTaskFailed responds to a RespondActivityTaskFailed 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().RespondActivityTaskFailed(gomock.Any(), ...).Return(...)
//	... := client.RespondActivityTaskFailed(...)
func (m *MockClient) RespondActivityTaskFailed(
	ctx context.Context,
	_FailRequest *shared.RespondActivityTaskFailedRequest,
	opts ...yarpc.CallOption,
) (err error) {

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

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

// RespondActivityTaskFailedByID responds to a RespondActivityTaskFailedByID 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().RespondActivityTaskFailedByID(gomock.Any(), ...).Return(...)
//	... := client.RespondActivityTaskFailedByID(...)
func (m *MockClient) RespondActivityTaskFailedByID(
	ctx context.Context,
	_FailRequest *shared.RespondActivityTaskFailedByIDRequest,
	opts ...yarpc.CallOption,
) (err error) {

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

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

// RespondDecisionTaskCompleted responds to a RespondDecisionTaskCompleted 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().RespondDecisionTaskCompleted(gomock.Any(), ...).Return(...)
//	... := client.RespondDecisionTaskCompleted(...)
func (m *MockClient) RespondDecisionTaskCompleted(
	ctx context.Context,
	_CompleteRequest *shared.RespondDecisionTaskCompletedRequest,
	opts ...yarpc.CallOption,
) (success *shared.RespondDecisionTaskCompletedResponse, err error) {

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

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

// RespondDecisionTaskFailed responds to a RespondDecisionTaskFailed 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().RespondDecisionTaskFailed(gomock.Any(), ...).Return(...)
//	... := client.RespondDecisionTaskFailed(...)
func (m *MockClient) RespondDecisionTaskFailed(
	ctx context.Context,
	_FailedRequest *shared.RespondDecisionTaskFailedRequest,
	opts ...yarpc.CallOption,
) (err error) {

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

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

// RespondQueryTaskCompleted responds to a RespondQueryTaskCompleted 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().RespondQueryTaskCompleted(gomock.Any(), ...).Return(...)
//	... := client.RespondQueryTaskCompleted(...)
func (m *MockClient) RespondQueryTaskCompleted(
	ctx context.Context,
	_CompleteRequest *shared.RespondQueryTaskCompletedRequest,
	opts ...yarpc.CallOption,
) (err error) {

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

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

// RestartWorkflowExecution responds to a RestartWorkflowExecution 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().RestartWorkflowExecution(gomock.Any(), ...).Return(...)
//	... := client.RestartWorkflowExecution(...)
func (m *MockClient) RestartWorkflowExecution(
	ctx context.Context,
	_RestartRequest *shared.RestartWorkflowExecutionRequest,
	opts ...yarpc.CallOption,
) (success *shared.RestartWorkflowExecutionResponse, err error) {

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

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

// ScanWorkflowExecutions responds to a ScanWorkflowExecutions 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().ScanWorkflowExecutions(gomock.Any(), ...).Return(...)
//	... := client.ScanWorkflowExecutions(...)
func (m *MockClient) ScanWorkflowExecutions(
	ctx context.Context,
	_ListRequest *shared.ListWorkflowExecutionsRequest,
	opts ...yarpc.CallOption,
) (success *shared.ListWorkflowExecutionsResponse, err error) {

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

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

// SignalWithStartWorkflowExecution responds to a SignalWithStartWorkflowExecution 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().SignalWithStartWorkflowExecution(gomock.Any(), ...).Return(...)
//	... := client.SignalWithStartWorkflowExecution(...)
func (m *MockClient) SignalWithStartWorkflowExecution(
	ctx context.Context,
	_SignalWithStartRequest *shared.SignalWithStartWorkflowExecutionRequest,
	opts ...yarpc.CallOption,
) (success *shared.StartWorkflowExecutionResponse, err error) {

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

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

// SignalWithStartWorkflowExecutionAsync responds to a SignalWithStartWorkflowExecutionAsync 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().SignalWithStartWorkflowExecutionAsync(gomock.Any(), ...).Return(...)
//	... := client.SignalWithStartWorkflowExecutionAsync(...)
func (m *MockClient) SignalWithStartWorkflowExecutionAsync(
	ctx context.Context,
	_SignalWithStartRequest *shared.SignalWithStartWorkflowExecutionAsyncRequest,
	opts ...yarpc.CallOption,
) (success *shared.SignalWithStartWorkflowExecutionAsyncResponse, err error) {

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

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

// SignalWorkflowExecution responds to a SignalWorkflowExecution 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().SignalWorkflowExecution(gomock.Any(), ...).Return(...)
//	... := client.SignalWorkflowExecution(...)
func (m *MockClient) SignalWorkflowExecution(
	ctx context.Context,
	_SignalRequest *shared.SignalWorkflowExecutionRequest,
	opts ...yarpc.CallOption,
) (err error) {

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

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

// StartWorkflowExecution responds to a StartWorkflowExecution 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().StartWorkflowExecution(gomock.Any(), ...).Return(...)
//	... := client.StartWorkflowExecution(...)
func (m *MockClient) StartWorkflowExecution(
	ctx context.Context,
	_StartRequest *shared.StartWorkflowExecutionRequest,
	opts ...yarpc.CallOption,
) (success *shared.StartWorkflowExecutionResponse, err error) {

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

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

// StartWorkflowExecutionAsync responds to a StartWorkflowExecutionAsync 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().StartWorkflowExecutionAsync(gomock.Any(), ...).Return(...)
//	... := client.StartWorkflowExecutionAsync(...)
func (m *MockClient) StartWorkflowExecutionAsync(
	ctx context.Context,
	_StartRequest *shared.StartWorkflowExecutionAsyncRequest,
	opts ...yarpc.CallOption,
) (success *shared.StartWorkflowExecutionAsyncResponse, err error) {

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

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

// TerminateWorkflowExecution responds to a TerminateWorkflowExecution 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().TerminateWorkflowExecution(gomock.Any(), ...).Return(...)
//	... := client.TerminateWorkflowExecution(...)
func (m *MockClient) TerminateWorkflowExecution(
	ctx context.Context,
	_TerminateRequest *shared.TerminateWorkflowExecutionRequest,
	opts ...yarpc.CallOption,
) (err error) {

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

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

// UpdateDomain responds to a UpdateDomain 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().UpdateDomain(gomock.Any(), ...).Return(...)
//	... := client.UpdateDomain(...)
func (m *MockClient) UpdateDomain(
	ctx context.Context,
	_UpdateRequest *shared.UpdateDomainRequest,
	opts ...yarpc.CallOption,
) (success *shared.UpdateDomainResponse, err error) {

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

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