mock_Client.go

// Code generated by mockery v2.53.5. DO NOT EDIT.

package client

import (
	context "context"

	client "go.temporal.io/sdk/client"

	converter "go.temporal.io/sdk/converter"

	enums "go.temporal.io/api/enums/v1"

	mock "github.com/stretchr/testify/mock"

	operatorservice "go.temporal.io/api/operatorservice/v1"

	workflowservice "go.temporal.io/api/workflowservice/v1"
)

// MockClient is an autogenerated mock type for the Client type
type MockClient struct {
	mock.Mock
}

type MockClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockClient) EXPECT() *MockClient_Expecter {
	return &MockClient_Expecter{mock: &_m.Mock}
}

// CancelWorkflow provides a mock function with given fields: ctx, workflowID, runID
func (_m *MockClient) CancelWorkflow(ctx context.Context, workflowID string, runID string) error {
	ret := _m.Called(ctx, workflowID, runID)

	if len(ret) == 0 {
		panic("no return value specified for CancelWorkflow")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = rf(ctx, workflowID, runID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockClient_CancelWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelWorkflow'
type MockClient_CancelWorkflow_Call struct {
	*mock.Call
}

// CancelWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - workflowID string
//   - runID string
func (_e *MockClient_Expecter) CancelWorkflow(ctx interface{}, workflowID interface{}, runID interface{}) *MockClient_CancelWorkflow_Call {
	return &MockClient_CancelWorkflow_Call{Call: _e.mock.On("CancelWorkflow", ctx, workflowID, runID)}
}

func (_c *MockClient_CancelWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string)) *MockClient_CancelWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_CancelWorkflow_Call) Return(_a0 error) *MockClient_CancelWorkflow_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_CancelWorkflow_Call) RunAndReturn(run func(context.Context, string, string) error) *MockClient_CancelWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// CheckHealth provides a mock function with given fields: ctx, request
func (_m *MockClient) CheckHealth(ctx context.Context, request *client.CheckHealthRequest) (*client.CheckHealthResponse, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for CheckHealth")
	}

	var r0 *client.CheckHealthResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *client.CheckHealthRequest) (*client.CheckHealthResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *client.CheckHealthRequest) *client.CheckHealthResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.CheckHealthResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *client.CheckHealthRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_CheckHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckHealth'
type MockClient_CheckHealth_Call struct {
	*mock.Call
}

// CheckHealth is a helper method to define mock.On call
//   - ctx context.Context
//   - request *client.CheckHealthRequest
func (_e *MockClient_Expecter) CheckHealth(ctx interface{}, request interface{}) *MockClient_CheckHealth_Call {
	return &MockClient_CheckHealth_Call{Call: _e.mock.On("CheckHealth", ctx, request)}
}

func (_c *MockClient_CheckHealth_Call) Run(run func(ctx context.Context, request *client.CheckHealthRequest)) *MockClient_CheckHealth_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*client.CheckHealthRequest))
	})
	return _c
}

func (_c *MockClient_CheckHealth_Call) Return(_a0 *client.CheckHealthResponse, _a1 error) *MockClient_CheckHealth_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_CheckHealth_Call) RunAndReturn(run func(context.Context, *client.CheckHealthRequest) (*client.CheckHealthResponse, error)) *MockClient_CheckHealth_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function with no fields
func (_m *MockClient) Close() {
	_m.Called()
}

// MockClient_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
type MockClient_Close_Call struct {
	*mock.Call
}

// Close is a helper method to define mock.On call
func (_e *MockClient_Expecter) Close() *MockClient_Close_Call {
	return &MockClient_Close_Call{Call: _e.mock.On("Close")}
}

func (_c *MockClient_Close_Call) Run(run func()) *MockClient_Close_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockClient_Close_Call) Return() *MockClient_Close_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockClient_Close_Call) RunAndReturn(run func()) *MockClient_Close_Call {
	_c.Run(run)
	return _c
}

// CompleteActivity provides a mock function with given fields: ctx, taskToken, result, err
func (_m *MockClient) CompleteActivity(ctx context.Context, taskToken []byte, result interface{}, err error) error {
	ret := _m.Called(ctx, taskToken, result, err)

	if len(ret) == 0 {
		panic("no return value specified for CompleteActivity")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []byte, interface{}, error) error); ok {
		r0 = rf(ctx, taskToken, result, err)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockClient_CompleteActivity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteActivity'
type MockClient_CompleteActivity_Call struct {
	*mock.Call
}

// CompleteActivity is a helper method to define mock.On call
//   - ctx context.Context
//   - taskToken []byte
//   - result interface{}
//   - err error
func (_e *MockClient_Expecter) CompleteActivity(ctx interface{}, taskToken interface{}, result interface{}, err interface{}) *MockClient_CompleteActivity_Call {
	return &MockClient_CompleteActivity_Call{Call: _e.mock.On("CompleteActivity", ctx, taskToken, result, err)}
}

func (_c *MockClient_CompleteActivity_Call) Run(run func(ctx context.Context, taskToken []byte, result interface{}, err error)) *MockClient_CompleteActivity_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]byte), args[2].(interface{}), args[3].(error))
	})
	return _c
}

func (_c *MockClient_CompleteActivity_Call) Return(_a0 error) *MockClient_CompleteActivity_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_CompleteActivity_Call) RunAndReturn(run func(context.Context, []byte, interface{}, error) error) *MockClient_CompleteActivity_Call {
	_c.Call.Return(run)
	return _c
}

// CompleteActivityByID provides a mock function with given fields: ctx, namespace, workflowID, runID, activityID, result, err
func (_m *MockClient) CompleteActivityByID(ctx context.Context, namespace string, workflowID string, runID string, activityID string, result interface{}, err error) error {
	ret := _m.Called(ctx, namespace, workflowID, runID, activityID, result, err)

	if len(ret) == 0 {
		panic("no return value specified for CompleteActivityByID")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, interface{}, error) error); ok {
		r0 = rf(ctx, namespace, workflowID, runID, activityID, result, err)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockClient_CompleteActivityByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteActivityByID'
type MockClient_CompleteActivityByID_Call struct {
	*mock.Call
}

// CompleteActivityByID is a helper method to define mock.On call
//   - ctx context.Context
//   - namespace string
//   - workflowID string
//   - runID string
//   - activityID string
//   - result interface{}
//   - err error
func (_e *MockClient_Expecter) CompleteActivityByID(ctx interface{}, namespace interface{}, workflowID interface{}, runID interface{}, activityID interface{}, result interface{}, err interface{}) *MockClient_CompleteActivityByID_Call {
	return &MockClient_CompleteActivityByID_Call{Call: _e.mock.On("CompleteActivityByID", ctx, namespace, workflowID, runID, activityID, result, err)}
}

func (_c *MockClient_CompleteActivityByID_Call) Run(run func(ctx context.Context, namespace string, workflowID string, runID string, activityID string, result interface{}, err error)) *MockClient_CompleteActivityByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(interface{}), args[6].(error))
	})
	return _c
}

func (_c *MockClient_CompleteActivityByID_Call) Return(_a0 error) *MockClient_CompleteActivityByID_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_CompleteActivityByID_Call) RunAndReturn(run func(context.Context, string, string, string, string, interface{}, error) error) *MockClient_CompleteActivityByID_Call {
	_c.Call.Return(run)
	return _c
}

// CountWorkflow provides a mock function with given fields: ctx, request
func (_m *MockClient) CountWorkflow(ctx context.Context, request *workflowservice.CountWorkflowExecutionsRequest) (*workflowservice.CountWorkflowExecutionsResponse, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for CountWorkflow")
	}

	var r0 *workflowservice.CountWorkflowExecutionsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.CountWorkflowExecutionsRequest) (*workflowservice.CountWorkflowExecutionsResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.CountWorkflowExecutionsRequest) *workflowservice.CountWorkflowExecutionsResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*workflowservice.CountWorkflowExecutionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *workflowservice.CountWorkflowExecutionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_CountWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountWorkflow'
type MockClient_CountWorkflow_Call struct {
	*mock.Call
}

// CountWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - request *workflowservice.CountWorkflowExecutionsRequest
func (_e *MockClient_Expecter) CountWorkflow(ctx interface{}, request interface{}) *MockClient_CountWorkflow_Call {
	return &MockClient_CountWorkflow_Call{Call: _e.mock.On("CountWorkflow", ctx, request)}
}

func (_c *MockClient_CountWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.CountWorkflowExecutionsRequest)) *MockClient_CountWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*workflowservice.CountWorkflowExecutionsRequest))
	})
	return _c
}

func (_c *MockClient_CountWorkflow_Call) Return(_a0 *workflowservice.CountWorkflowExecutionsResponse, _a1 error) *MockClient_CountWorkflow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_CountWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.CountWorkflowExecutionsRequest) (*workflowservice.CountWorkflowExecutionsResponse, error)) *MockClient_CountWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentClient provides a mock function with no fields
func (_m *MockClient) DeploymentClient() client.DeploymentClient {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for DeploymentClient")
	}

	var r0 client.DeploymentClient
	if rf, ok := ret.Get(0).(func() client.DeploymentClient); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(client.DeploymentClient)
		}
	}

	return r0
}

// MockClient_DeploymentClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeploymentClient'
type MockClient_DeploymentClient_Call struct {
	*mock.Call
}

// DeploymentClient is a helper method to define mock.On call
func (_e *MockClient_Expecter) DeploymentClient() *MockClient_DeploymentClient_Call {
	return &MockClient_DeploymentClient_Call{Call: _e.mock.On("DeploymentClient")}
}

func (_c *MockClient_DeploymentClient_Call) Run(run func()) *MockClient_DeploymentClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockClient_DeploymentClient_Call) Return(_a0 client.DeploymentClient) *MockClient_DeploymentClient_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_DeploymentClient_Call) RunAndReturn(run func() client.DeploymentClient) *MockClient_DeploymentClient_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTaskQueue provides a mock function with given fields: ctx, taskqueue, taskqueueType
func (_m *MockClient) DescribeTaskQueue(ctx context.Context, taskqueue string, taskqueueType enums.TaskQueueType) (*workflowservice.DescribeTaskQueueResponse, error) {
	ret := _m.Called(ctx, taskqueue, taskqueueType)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTaskQueue")
	}

	var r0 *workflowservice.DescribeTaskQueueResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, enums.TaskQueueType) (*workflowservice.DescribeTaskQueueResponse, error)); ok {
		return rf(ctx, taskqueue, taskqueueType)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, enums.TaskQueueType) *workflowservice.DescribeTaskQueueResponse); ok {
		r0 = rf(ctx, taskqueue, taskqueueType)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*workflowservice.DescribeTaskQueueResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, enums.TaskQueueType) error); ok {
		r1 = rf(ctx, taskqueue, taskqueueType)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_DescribeTaskQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTaskQueue'
type MockClient_DescribeTaskQueue_Call struct {
	*mock.Call
}

// DescribeTaskQueue is a helper method to define mock.On call
//   - ctx context.Context
//   - taskqueue string
//   - taskqueueType enums.TaskQueueType
func (_e *MockClient_Expecter) DescribeTaskQueue(ctx interface{}, taskqueue interface{}, taskqueueType interface{}) *MockClient_DescribeTaskQueue_Call {
	return &MockClient_DescribeTaskQueue_Call{Call: _e.mock.On("DescribeTaskQueue", ctx, taskqueue, taskqueueType)}
}

func (_c *MockClient_DescribeTaskQueue_Call) Run(run func(ctx context.Context, taskqueue string, taskqueueType enums.TaskQueueType)) *MockClient_DescribeTaskQueue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(enums.TaskQueueType))
	})
	return _c
}

func (_c *MockClient_DescribeTaskQueue_Call) Return(_a0 *workflowservice.DescribeTaskQueueResponse, _a1 error) *MockClient_DescribeTaskQueue_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeTaskQueue_Call) RunAndReturn(run func(context.Context, string, enums.TaskQueueType) (*workflowservice.DescribeTaskQueueResponse, error)) *MockClient_DescribeTaskQueue_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTaskQueueEnhanced provides a mock function with given fields: ctx, options
func (_m *MockClient) DescribeTaskQueueEnhanced(ctx context.Context, options client.DescribeTaskQueueEnhancedOptions) (client.TaskQueueDescription, error) {
	ret := _m.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTaskQueueEnhanced")
	}

	var r0 client.TaskQueueDescription
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, client.DescribeTaskQueueEnhancedOptions) (client.TaskQueueDescription, error)); ok {
		return rf(ctx, options)
	}
	if rf, ok := ret.Get(0).(func(context.Context, client.DescribeTaskQueueEnhancedOptions) client.TaskQueueDescription); ok {
		r0 = rf(ctx, options)
	} else {
		r0 = ret.Get(0).(client.TaskQueueDescription)
	}

	if rf, ok := ret.Get(1).(func(context.Context, client.DescribeTaskQueueEnhancedOptions) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_DescribeTaskQueueEnhanced_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTaskQueueEnhanced'
type MockClient_DescribeTaskQueueEnhanced_Call struct {
	*mock.Call
}

// DescribeTaskQueueEnhanced is a helper method to define mock.On call
//   - ctx context.Context
//   - options client.DescribeTaskQueueEnhancedOptions
func (_e *MockClient_Expecter) DescribeTaskQueueEnhanced(ctx interface{}, options interface{}) *MockClient_DescribeTaskQueueEnhanced_Call {
	return &MockClient_DescribeTaskQueueEnhanced_Call{Call: _e.mock.On("DescribeTaskQueueEnhanced", ctx, options)}
}

func (_c *MockClient_DescribeTaskQueueEnhanced_Call) Run(run func(ctx context.Context, options client.DescribeTaskQueueEnhancedOptions)) *MockClient_DescribeTaskQueueEnhanced_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(client.DescribeTaskQueueEnhancedOptions))
	})
	return _c
}

func (_c *MockClient_DescribeTaskQueueEnhanced_Call) Return(_a0 client.TaskQueueDescription, _a1 error) *MockClient_DescribeTaskQueueEnhanced_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeTaskQueueEnhanced_Call) RunAndReturn(run func(context.Context, client.DescribeTaskQueueEnhancedOptions) (client.TaskQueueDescription, error)) *MockClient_DescribeTaskQueueEnhanced_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeWorkflowExecution provides a mock function with given fields: ctx, workflowID, runID
func (_m *MockClient) DescribeWorkflowExecution(ctx context.Context, workflowID string, runID string) (*workflowservice.DescribeWorkflowExecutionResponse, error) {
	ret := _m.Called(ctx, workflowID, runID)

	if len(ret) == 0 {
		panic("no return value specified for DescribeWorkflowExecution")
	}

	var r0 *workflowservice.DescribeWorkflowExecutionResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) (*workflowservice.DescribeWorkflowExecutionResponse, error)); ok {
		return rf(ctx, workflowID, runID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string) *workflowservice.DescribeWorkflowExecutionResponse); ok {
		r0 = rf(ctx, workflowID, runID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*workflowservice.DescribeWorkflowExecutionResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, workflowID, runID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_DescribeWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeWorkflowExecution'
type MockClient_DescribeWorkflowExecution_Call struct {
	*mock.Call
}

// DescribeWorkflowExecution is a helper method to define mock.On call
//   - ctx context.Context
//   - workflowID string
//   - runID string
func (_e *MockClient_Expecter) DescribeWorkflowExecution(ctx interface{}, workflowID interface{}, runID interface{}) *MockClient_DescribeWorkflowExecution_Call {
	return &MockClient_DescribeWorkflowExecution_Call{Call: _e.mock.On("DescribeWorkflowExecution", ctx, workflowID, runID)}
}

func (_c *MockClient_DescribeWorkflowExecution_Call) Run(run func(ctx context.Context, workflowID string, runID string)) *MockClient_DescribeWorkflowExecution_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_DescribeWorkflowExecution_Call) Return(_a0 *workflowservice.DescribeWorkflowExecutionResponse, _a1 error) *MockClient_DescribeWorkflowExecution_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeWorkflowExecution_Call) RunAndReturn(run func(context.Context, string, string) (*workflowservice.DescribeWorkflowExecutionResponse, error)) *MockClient_DescribeWorkflowExecution_Call {
	_c.Call.Return(run)
	return _c
}

// ExecuteWorkflow provides a mock function with given fields: ctx, options, workflow, args
func (_m *MockClient) ExecuteWorkflow(ctx context.Context, options client.StartWorkflowOptions, workflow interface{}, args ...interface{}) (client.WorkflowRun, error) {
	var _ca []interface{}
	_ca = append(_ca, ctx, options, workflow)
	_ca = append(_ca, args...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ExecuteWorkflow")
	}

	var r0 client.WorkflowRun
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, client.StartWorkflowOptions, interface{}, ...interface{}) (client.WorkflowRun, error)); ok {
		return rf(ctx, options, workflow, args...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, client.StartWorkflowOptions, interface{}, ...interface{}) client.WorkflowRun); ok {
		r0 = rf(ctx, options, workflow, args...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(client.WorkflowRun)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, client.StartWorkflowOptions, interface{}, ...interface{}) error); ok {
		r1 = rf(ctx, options, workflow, args...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ExecuteWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExecuteWorkflow'
type MockClient_ExecuteWorkflow_Call struct {
	*mock.Call
}

// ExecuteWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - options client.StartWorkflowOptions
//   - workflow interface{}
//   - args ...interface{}
func (_e *MockClient_Expecter) ExecuteWorkflow(ctx interface{}, options interface{}, workflow interface{}, args ...interface{}) *MockClient_ExecuteWorkflow_Call {
	return &MockClient_ExecuteWorkflow_Call{Call: _e.mock.On("ExecuteWorkflow",
		append([]interface{}{ctx, options, workflow}, args...)...)}
}

func (_c *MockClient_ExecuteWorkflow_Call) Run(run func(ctx context.Context, options client.StartWorkflowOptions, workflow interface{}, args ...interface{})) *MockClient_ExecuteWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]interface{}, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		run(args[0].(context.Context), args[1].(client.StartWorkflowOptions), args[2].(interface{}), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ExecuteWorkflow_Call) Return(_a0 client.WorkflowRun, _a1 error) *MockClient_ExecuteWorkflow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ExecuteWorkflow_Call) RunAndReturn(run func(context.Context, client.StartWorkflowOptions, interface{}, ...interface{}) (client.WorkflowRun, error)) *MockClient_ExecuteWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// GetSearchAttributes provides a mock function with given fields: ctx
func (_m *MockClient) GetSearchAttributes(ctx context.Context) (*workflowservice.GetSearchAttributesResponse, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetSearchAttributes")
	}

	var r0 *workflowservice.GetSearchAttributesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (*workflowservice.GetSearchAttributesResponse, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) *workflowservice.GetSearchAttributesResponse); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*workflowservice.GetSearchAttributesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_GetSearchAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSearchAttributes'
type MockClient_GetSearchAttributes_Call struct {
	*mock.Call
}

// GetSearchAttributes is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockClient_Expecter) GetSearchAttributes(ctx interface{}) *MockClient_GetSearchAttributes_Call {
	return &MockClient_GetSearchAttributes_Call{Call: _e.mock.On("GetSearchAttributes", ctx)}
}

func (_c *MockClient_GetSearchAttributes_Call) Run(run func(ctx context.Context)) *MockClient_GetSearchAttributes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_GetSearchAttributes_Call) Return(_a0 *workflowservice.GetSearchAttributesResponse, _a1 error) *MockClient_GetSearchAttributes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_GetSearchAttributes_Call) RunAndReturn(run func(context.Context) (*workflowservice.GetSearchAttributesResponse, error)) *MockClient_GetSearchAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// GetWorkerBuildIdCompatibility provides a mock function with given fields: ctx, options
func (_m *MockClient) GetWorkerBuildIdCompatibility(ctx context.Context, options *client.GetWorkerBuildIdCompatibilityOptions) (*client.WorkerBuildIDVersionSets, error) {
	ret := _m.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for GetWorkerBuildIdCompatibility")
	}

	var r0 *client.WorkerBuildIDVersionSets
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *client.GetWorkerBuildIdCompatibilityOptions) (*client.WorkerBuildIDVersionSets, error)); ok {
		return rf(ctx, options)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *client.GetWorkerBuildIdCompatibilityOptions) *client.WorkerBuildIDVersionSets); ok {
		r0 = rf(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.WorkerBuildIDVersionSets)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *client.GetWorkerBuildIdCompatibilityOptions) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_GetWorkerBuildIdCompatibility_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkerBuildIdCompatibility'
type MockClient_GetWorkerBuildIdCompatibility_Call struct {
	*mock.Call
}

// GetWorkerBuildIdCompatibility is a helper method to define mock.On call
//   - ctx context.Context
//   - options *client.GetWorkerBuildIdCompatibilityOptions
func (_e *MockClient_Expecter) GetWorkerBuildIdCompatibility(ctx interface{}, options interface{}) *MockClient_GetWorkerBuildIdCompatibility_Call {
	return &MockClient_GetWorkerBuildIdCompatibility_Call{Call: _e.mock.On("GetWorkerBuildIdCompatibility", ctx, options)}
}

func (_c *MockClient_GetWorkerBuildIdCompatibility_Call) Run(run func(ctx context.Context, options *client.GetWorkerBuildIdCompatibilityOptions)) *MockClient_GetWorkerBuildIdCompatibility_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*client.GetWorkerBuildIdCompatibilityOptions))
	})
	return _c
}

func (_c *MockClient_GetWorkerBuildIdCompatibility_Call) Return(_a0 *client.WorkerBuildIDVersionSets, _a1 error) *MockClient_GetWorkerBuildIdCompatibility_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_GetWorkerBuildIdCompatibility_Call) RunAndReturn(run func(context.Context, *client.GetWorkerBuildIdCompatibilityOptions) (*client.WorkerBuildIDVersionSets, error)) *MockClient_GetWorkerBuildIdCompatibility_Call {
	_c.Call.Return(run)
	return _c
}

// GetWorkerTaskReachability provides a mock function with given fields: ctx, options
func (_m *MockClient) GetWorkerTaskReachability(ctx context.Context, options *client.GetWorkerTaskReachabilityOptions) (*client.WorkerTaskReachability, error) {
	ret := _m.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for GetWorkerTaskReachability")
	}

	var r0 *client.WorkerTaskReachability
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *client.GetWorkerTaskReachabilityOptions) (*client.WorkerTaskReachability, error)); ok {
		return rf(ctx, options)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *client.GetWorkerTaskReachabilityOptions) *client.WorkerTaskReachability); ok {
		r0 = rf(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.WorkerTaskReachability)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *client.GetWorkerTaskReachabilityOptions) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_GetWorkerTaskReachability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkerTaskReachability'
type MockClient_GetWorkerTaskReachability_Call struct {
	*mock.Call
}

// GetWorkerTaskReachability is a helper method to define mock.On call
//   - ctx context.Context
//   - options *client.GetWorkerTaskReachabilityOptions
func (_e *MockClient_Expecter) GetWorkerTaskReachability(ctx interface{}, options interface{}) *MockClient_GetWorkerTaskReachability_Call {
	return &MockClient_GetWorkerTaskReachability_Call{Call: _e.mock.On("GetWorkerTaskReachability", ctx, options)}
}

func (_c *MockClient_GetWorkerTaskReachability_Call) Run(run func(ctx context.Context, options *client.GetWorkerTaskReachabilityOptions)) *MockClient_GetWorkerTaskReachability_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*client.GetWorkerTaskReachabilityOptions))
	})
	return _c
}

func (_c *MockClient_GetWorkerTaskReachability_Call) Return(_a0 *client.WorkerTaskReachability, _a1 error) *MockClient_GetWorkerTaskReachability_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_GetWorkerTaskReachability_Call) RunAndReturn(run func(context.Context, *client.GetWorkerTaskReachabilityOptions) (*client.WorkerTaskReachability, error)) *MockClient_GetWorkerTaskReachability_Call {
	_c.Call.Return(run)
	return _c
}

// GetWorkerVersioningRules provides a mock function with given fields: ctx, options
func (_m *MockClient) GetWorkerVersioningRules(ctx context.Context, options client.GetWorkerVersioningOptions) (*client.WorkerVersioningRules, error) {
	ret := _m.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for GetWorkerVersioningRules")
	}

	var r0 *client.WorkerVersioningRules
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, client.GetWorkerVersioningOptions) (*client.WorkerVersioningRules, error)); ok {
		return rf(ctx, options)
	}
	if rf, ok := ret.Get(0).(func(context.Context, client.GetWorkerVersioningOptions) *client.WorkerVersioningRules); ok {
		r0 = rf(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.WorkerVersioningRules)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, client.GetWorkerVersioningOptions) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_GetWorkerVersioningRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkerVersioningRules'
type MockClient_GetWorkerVersioningRules_Call struct {
	*mock.Call
}

// GetWorkerVersioningRules is a helper method to define mock.On call
//   - ctx context.Context
//   - options client.GetWorkerVersioningOptions
func (_e *MockClient_Expecter) GetWorkerVersioningRules(ctx interface{}, options interface{}) *MockClient_GetWorkerVersioningRules_Call {
	return &MockClient_GetWorkerVersioningRules_Call{Call: _e.mock.On("GetWorkerVersioningRules", ctx, options)}
}

func (_c *MockClient_GetWorkerVersioningRules_Call) Run(run func(ctx context.Context, options client.GetWorkerVersioningOptions)) *MockClient_GetWorkerVersioningRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(client.GetWorkerVersioningOptions))
	})
	return _c
}

func (_c *MockClient_GetWorkerVersioningRules_Call) Return(_a0 *client.WorkerVersioningRules, _a1 error) *MockClient_GetWorkerVersioningRules_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_GetWorkerVersioningRules_Call) RunAndReturn(run func(context.Context, client.GetWorkerVersioningOptions) (*client.WorkerVersioningRules, error)) *MockClient_GetWorkerVersioningRules_Call {
	_c.Call.Return(run)
	return _c
}

// GetWorkflow provides a mock function with given fields: ctx, workflowID, runID
func (_m *MockClient) GetWorkflow(ctx context.Context, workflowID string, runID string) client.WorkflowRun {
	ret := _m.Called(ctx, workflowID, runID)

	if len(ret) == 0 {
		panic("no return value specified for GetWorkflow")
	}

	var r0 client.WorkflowRun
	if rf, ok := ret.Get(0).(func(context.Context, string, string) client.WorkflowRun); ok {
		r0 = rf(ctx, workflowID, runID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(client.WorkflowRun)
		}
	}

	return r0
}

// MockClient_GetWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkflow'
type MockClient_GetWorkflow_Call struct {
	*mock.Call
}

// GetWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - workflowID string
//   - runID string
func (_e *MockClient_Expecter) GetWorkflow(ctx interface{}, workflowID interface{}, runID interface{}) *MockClient_GetWorkflow_Call {
	return &MockClient_GetWorkflow_Call{Call: _e.mock.On("GetWorkflow", ctx, workflowID, runID)}
}

func (_c *MockClient_GetWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string)) *MockClient_GetWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_GetWorkflow_Call) Return(_a0 client.WorkflowRun) *MockClient_GetWorkflow_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_GetWorkflow_Call) RunAndReturn(run func(context.Context, string, string) client.WorkflowRun) *MockClient_GetWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// GetWorkflowHistory provides a mock function with given fields: ctx, workflowID, runID, isLongPoll, filterType
func (_m *MockClient) GetWorkflowHistory(ctx context.Context, workflowID string, runID string, isLongPoll bool, filterType enums.HistoryEventFilterType) client.HistoryEventIterator {
	ret := _m.Called(ctx, workflowID, runID, isLongPoll, filterType)

	if len(ret) == 0 {
		panic("no return value specified for GetWorkflowHistory")
	}

	var r0 client.HistoryEventIterator
	if rf, ok := ret.Get(0).(func(context.Context, string, string, bool, enums.HistoryEventFilterType) client.HistoryEventIterator); ok {
		r0 = rf(ctx, workflowID, runID, isLongPoll, filterType)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(client.HistoryEventIterator)
		}
	}

	return r0
}

// MockClient_GetWorkflowHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkflowHistory'
type MockClient_GetWorkflowHistory_Call struct {
	*mock.Call
}

// GetWorkflowHistory is a helper method to define mock.On call
//   - ctx context.Context
//   - workflowID string
//   - runID string
//   - isLongPoll bool
//   - filterType enums.HistoryEventFilterType
func (_e *MockClient_Expecter) GetWorkflowHistory(ctx interface{}, workflowID interface{}, runID interface{}, isLongPoll interface{}, filterType interface{}) *MockClient_GetWorkflowHistory_Call {
	return &MockClient_GetWorkflowHistory_Call{Call: _e.mock.On("GetWorkflowHistory", ctx, workflowID, runID, isLongPoll, filterType)}
}

func (_c *MockClient_GetWorkflowHistory_Call) Run(run func(ctx context.Context, workflowID string, runID string, isLongPoll bool, filterType enums.HistoryEventFilterType)) *MockClient_GetWorkflowHistory_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(bool), args[4].(enums.HistoryEventFilterType))
	})
	return _c
}

func (_c *MockClient_GetWorkflowHistory_Call) Return(_a0 client.HistoryEventIterator) *MockClient_GetWorkflowHistory_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_GetWorkflowHistory_Call) RunAndReturn(run func(context.Context, string, string, bool, enums.HistoryEventFilterType) client.HistoryEventIterator) *MockClient_GetWorkflowHistory_Call {
	_c.Call.Return(run)
	return _c
}

// GetWorkflowUpdateHandle provides a mock function with given fields: ref
func (_m *MockClient) GetWorkflowUpdateHandle(ref client.GetWorkflowUpdateHandleOptions) client.WorkflowUpdateHandle {
	ret := _m.Called(ref)

	if len(ret) == 0 {
		panic("no return value specified for GetWorkflowUpdateHandle")
	}

	var r0 client.WorkflowUpdateHandle
	if rf, ok := ret.Get(0).(func(client.GetWorkflowUpdateHandleOptions) client.WorkflowUpdateHandle); ok {
		r0 = rf(ref)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(client.WorkflowUpdateHandle)
		}
	}

	return r0
}

// MockClient_GetWorkflowUpdateHandle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkflowUpdateHandle'
type MockClient_GetWorkflowUpdateHandle_Call struct {
	*mock.Call
}

// GetWorkflowUpdateHandle is a helper method to define mock.On call
//   - ref client.GetWorkflowUpdateHandleOptions
func (_e *MockClient_Expecter) GetWorkflowUpdateHandle(ref interface{}) *MockClient_GetWorkflowUpdateHandle_Call {
	return &MockClient_GetWorkflowUpdateHandle_Call{Call: _e.mock.On("GetWorkflowUpdateHandle", ref)}
}

func (_c *MockClient_GetWorkflowUpdateHandle_Call) Run(run func(ref client.GetWorkflowUpdateHandleOptions)) *MockClient_GetWorkflowUpdateHandle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(client.GetWorkflowUpdateHandleOptions))
	})
	return _c
}

func (_c *MockClient_GetWorkflowUpdateHandle_Call) Return(_a0 client.WorkflowUpdateHandle) *MockClient_GetWorkflowUpdateHandle_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_GetWorkflowUpdateHandle_Call) RunAndReturn(run func(client.GetWorkflowUpdateHandleOptions) client.WorkflowUpdateHandle) *MockClient_GetWorkflowUpdateHandle_Call {
	_c.Call.Return(run)
	return _c
}

// ListArchivedWorkflow provides a mock function with given fields: ctx, request
func (_m *MockClient) ListArchivedWorkflow(ctx context.Context, request *workflowservice.ListArchivedWorkflowExecutionsRequest) (*workflowservice.ListArchivedWorkflowExecutionsResponse, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for ListArchivedWorkflow")
	}

	var r0 *workflowservice.ListArchivedWorkflowExecutionsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListArchivedWorkflowExecutionsRequest) (*workflowservice.ListArchivedWorkflowExecutionsResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListArchivedWorkflowExecutionsRequest) *workflowservice.ListArchivedWorkflowExecutionsResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*workflowservice.ListArchivedWorkflowExecutionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *workflowservice.ListArchivedWorkflowExecutionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ListArchivedWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListArchivedWorkflow'
type MockClient_ListArchivedWorkflow_Call struct {
	*mock.Call
}

// ListArchivedWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - request *workflowservice.ListArchivedWorkflowExecutionsRequest
func (_e *MockClient_Expecter) ListArchivedWorkflow(ctx interface{}, request interface{}) *MockClient_ListArchivedWorkflow_Call {
	return &MockClient_ListArchivedWorkflow_Call{Call: _e.mock.On("ListArchivedWorkflow", ctx, request)}
}

func (_c *MockClient_ListArchivedWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.ListArchivedWorkflowExecutionsRequest)) *MockClient_ListArchivedWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*workflowservice.ListArchivedWorkflowExecutionsRequest))
	})
	return _c
}

func (_c *MockClient_ListArchivedWorkflow_Call) Return(_a0 *workflowservice.ListArchivedWorkflowExecutionsResponse, _a1 error) *MockClient_ListArchivedWorkflow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ListArchivedWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.ListArchivedWorkflowExecutionsRequest) (*workflowservice.ListArchivedWorkflowExecutionsResponse, error)) *MockClient_ListArchivedWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// ListClosedWorkflow provides a mock function with given fields: ctx, request
func (_m *MockClient) ListClosedWorkflow(ctx context.Context, request *workflowservice.ListClosedWorkflowExecutionsRequest) (*workflowservice.ListClosedWorkflowExecutionsResponse, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for ListClosedWorkflow")
	}

	var r0 *workflowservice.ListClosedWorkflowExecutionsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListClosedWorkflowExecutionsRequest) (*workflowservice.ListClosedWorkflowExecutionsResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListClosedWorkflowExecutionsRequest) *workflowservice.ListClosedWorkflowExecutionsResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*workflowservice.ListClosedWorkflowExecutionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *workflowservice.ListClosedWorkflowExecutionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ListClosedWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClosedWorkflow'
type MockClient_ListClosedWorkflow_Call struct {
	*mock.Call
}

// ListClosedWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - request *workflowservice.ListClosedWorkflowExecutionsRequest
func (_e *MockClient_Expecter) ListClosedWorkflow(ctx interface{}, request interface{}) *MockClient_ListClosedWorkflow_Call {
	return &MockClient_ListClosedWorkflow_Call{Call: _e.mock.On("ListClosedWorkflow", ctx, request)}
}

func (_c *MockClient_ListClosedWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.ListClosedWorkflowExecutionsRequest)) *MockClient_ListClosedWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*workflowservice.ListClosedWorkflowExecutionsRequest))
	})
	return _c
}

func (_c *MockClient_ListClosedWorkflow_Call) Return(_a0 *workflowservice.ListClosedWorkflowExecutionsResponse, _a1 error) *MockClient_ListClosedWorkflow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ListClosedWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.ListClosedWorkflowExecutionsRequest) (*workflowservice.ListClosedWorkflowExecutionsResponse, error)) *MockClient_ListClosedWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// ListOpenWorkflow provides a mock function with given fields: ctx, request
func (_m *MockClient) ListOpenWorkflow(ctx context.Context, request *workflowservice.ListOpenWorkflowExecutionsRequest) (*workflowservice.ListOpenWorkflowExecutionsResponse, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for ListOpenWorkflow")
	}

	var r0 *workflowservice.ListOpenWorkflowExecutionsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListOpenWorkflowExecutionsRequest) (*workflowservice.ListOpenWorkflowExecutionsResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListOpenWorkflowExecutionsRequest) *workflowservice.ListOpenWorkflowExecutionsResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*workflowservice.ListOpenWorkflowExecutionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *workflowservice.ListOpenWorkflowExecutionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ListOpenWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOpenWorkflow'
type MockClient_ListOpenWorkflow_Call struct {
	*mock.Call
}

// ListOpenWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - request *workflowservice.ListOpenWorkflowExecutionsRequest
func (_e *MockClient_Expecter) ListOpenWorkflow(ctx interface{}, request interface{}) *MockClient_ListOpenWorkflow_Call {
	return &MockClient_ListOpenWorkflow_Call{Call: _e.mock.On("ListOpenWorkflow", ctx, request)}
}

func (_c *MockClient_ListOpenWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.ListOpenWorkflowExecutionsRequest)) *MockClient_ListOpenWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*workflowservice.ListOpenWorkflowExecutionsRequest))
	})
	return _c
}

func (_c *MockClient_ListOpenWorkflow_Call) Return(_a0 *workflowservice.ListOpenWorkflowExecutionsResponse, _a1 error) *MockClient_ListOpenWorkflow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ListOpenWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.ListOpenWorkflowExecutionsRequest) (*workflowservice.ListOpenWorkflowExecutionsResponse, error)) *MockClient_ListOpenWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// ListWorkflow provides a mock function with given fields: ctx, request
func (_m *MockClient) ListWorkflow(ctx context.Context, request *workflowservice.ListWorkflowExecutionsRequest) (*workflowservice.ListWorkflowExecutionsResponse, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for ListWorkflow")
	}

	var r0 *workflowservice.ListWorkflowExecutionsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListWorkflowExecutionsRequest) (*workflowservice.ListWorkflowExecutionsResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ListWorkflowExecutionsRequest) *workflowservice.ListWorkflowExecutionsResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*workflowservice.ListWorkflowExecutionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *workflowservice.ListWorkflowExecutionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ListWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListWorkflow'
type MockClient_ListWorkflow_Call struct {
	*mock.Call
}

// ListWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - request *workflowservice.ListWorkflowExecutionsRequest
func (_e *MockClient_Expecter) ListWorkflow(ctx interface{}, request interface{}) *MockClient_ListWorkflow_Call {
	return &MockClient_ListWorkflow_Call{Call: _e.mock.On("ListWorkflow", ctx, request)}
}

func (_c *MockClient_ListWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.ListWorkflowExecutionsRequest)) *MockClient_ListWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*workflowservice.ListWorkflowExecutionsRequest))
	})
	return _c
}

func (_c *MockClient_ListWorkflow_Call) Return(_a0 *workflowservice.ListWorkflowExecutionsResponse, _a1 error) *MockClient_ListWorkflow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ListWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.ListWorkflowExecutionsRequest) (*workflowservice.ListWorkflowExecutionsResponse, error)) *MockClient_ListWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// NewWithStartWorkflowOperation provides a mock function with given fields: options, workflow, args
func (_m *MockClient) NewWithStartWorkflowOperation(options client.StartWorkflowOptions, workflow interface{}, args ...interface{}) client.WithStartWorkflowOperation {
	var _ca []interface{}
	_ca = append(_ca, options, workflow)
	_ca = append(_ca, args...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for NewWithStartWorkflowOperation")
	}

	var r0 client.WithStartWorkflowOperation
	if rf, ok := ret.Get(0).(func(client.StartWorkflowOptions, interface{}, ...interface{}) client.WithStartWorkflowOperation); ok {
		r0 = rf(options, workflow, args...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(client.WithStartWorkflowOperation)
		}
	}

	return r0
}

// MockClient_NewWithStartWorkflowOperation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewWithStartWorkflowOperation'
type MockClient_NewWithStartWorkflowOperation_Call struct {
	*mock.Call
}

// NewWithStartWorkflowOperation is a helper method to define mock.On call
//   - options client.StartWorkflowOptions
//   - workflow interface{}
//   - args ...interface{}
func (_e *MockClient_Expecter) NewWithStartWorkflowOperation(options interface{}, workflow interface{}, args ...interface{}) *MockClient_NewWithStartWorkflowOperation_Call {
	return &MockClient_NewWithStartWorkflowOperation_Call{Call: _e.mock.On("NewWithStartWorkflowOperation",
		append([]interface{}{options, workflow}, args...)...)}
}

func (_c *MockClient_NewWithStartWorkflowOperation_Call) Run(run func(options client.StartWorkflowOptions, workflow interface{}, args ...interface{})) *MockClient_NewWithStartWorkflowOperation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]interface{}, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		run(args[0].(client.StartWorkflowOptions), args[1].(interface{}), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_NewWithStartWorkflowOperation_Call) Return(_a0 client.WithStartWorkflowOperation) *MockClient_NewWithStartWorkflowOperation_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_NewWithStartWorkflowOperation_Call) RunAndReturn(run func(client.StartWorkflowOptions, interface{}, ...interface{}) client.WithStartWorkflowOperation) *MockClient_NewWithStartWorkflowOperation_Call {
	_c.Call.Return(run)
	return _c
}

// OperatorService provides a mock function with no fields
func (_m *MockClient) OperatorService() operatorservice.OperatorServiceClient {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for OperatorService")
	}

	var r0 operatorservice.OperatorServiceClient
	if rf, ok := ret.Get(0).(func() operatorservice.OperatorServiceClient); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(operatorservice.OperatorServiceClient)
		}
	}

	return r0
}

// MockClient_OperatorService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OperatorService'
type MockClient_OperatorService_Call struct {
	*mock.Call
}

// OperatorService is a helper method to define mock.On call
func (_e *MockClient_Expecter) OperatorService() *MockClient_OperatorService_Call {
	return &MockClient_OperatorService_Call{Call: _e.mock.On("OperatorService")}
}

func (_c *MockClient_OperatorService_Call) Run(run func()) *MockClient_OperatorService_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockClient_OperatorService_Call) Return(_a0 operatorservice.OperatorServiceClient) *MockClient_OperatorService_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_OperatorService_Call) RunAndReturn(run func() operatorservice.OperatorServiceClient) *MockClient_OperatorService_Call {
	_c.Call.Return(run)
	return _c
}

// QueryWorkflow provides a mock function with given fields: ctx, workflowID, runID, queryType, args
func (_m *MockClient) QueryWorkflow(ctx context.Context, workflowID string, runID string, queryType string, args ...interface{}) (converter.EncodedValue, error) {
	var _ca []interface{}
	_ca = append(_ca, ctx, workflowID, runID, queryType)
	_ca = append(_ca, args...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for QueryWorkflow")
	}

	var r0 converter.EncodedValue
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, ...interface{}) (converter.EncodedValue, error)); ok {
		return rf(ctx, workflowID, runID, queryType, args...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, ...interface{}) converter.EncodedValue); ok {
		r0 = rf(ctx, workflowID, runID, queryType, args...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(converter.EncodedValue)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string, ...interface{}) error); ok {
		r1 = rf(ctx, workflowID, runID, queryType, args...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_QueryWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryWorkflow'
type MockClient_QueryWorkflow_Call struct {
	*mock.Call
}

// QueryWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - workflowID string
//   - runID string
//   - queryType string
//   - args ...interface{}
func (_e *MockClient_Expecter) QueryWorkflow(ctx interface{}, workflowID interface{}, runID interface{}, queryType interface{}, args ...interface{}) *MockClient_QueryWorkflow_Call {
	return &MockClient_QueryWorkflow_Call{Call: _e.mock.On("QueryWorkflow",
		append([]interface{}{ctx, workflowID, runID, queryType}, args...)...)}
}

func (_c *MockClient_QueryWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string, queryType string, args ...interface{})) *MockClient_QueryWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]interface{}, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_QueryWorkflow_Call) Return(_a0 converter.EncodedValue, _a1 error) *MockClient_QueryWorkflow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_QueryWorkflow_Call) RunAndReturn(run func(context.Context, string, string, string, ...interface{}) (converter.EncodedValue, error)) *MockClient_QueryWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// QueryWorkflowWithOptions provides a mock function with given fields: ctx, request
func (_m *MockClient) QueryWorkflowWithOptions(ctx context.Context, request *client.QueryWorkflowWithOptionsRequest) (*client.QueryWorkflowWithOptionsResponse, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for QueryWorkflowWithOptions")
	}

	var r0 *client.QueryWorkflowWithOptionsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *client.QueryWorkflowWithOptionsRequest) (*client.QueryWorkflowWithOptionsResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *client.QueryWorkflowWithOptionsRequest) *client.QueryWorkflowWithOptionsResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.QueryWorkflowWithOptionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *client.QueryWorkflowWithOptionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_QueryWorkflowWithOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryWorkflowWithOptions'
type MockClient_QueryWorkflowWithOptions_Call struct {
	*mock.Call
}

// QueryWorkflowWithOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - request *client.QueryWorkflowWithOptionsRequest
func (_e *MockClient_Expecter) QueryWorkflowWithOptions(ctx interface{}, request interface{}) *MockClient_QueryWorkflowWithOptions_Call {
	return &MockClient_QueryWorkflowWithOptions_Call{Call: _e.mock.On("QueryWorkflowWithOptions", ctx, request)}
}

func (_c *MockClient_QueryWorkflowWithOptions_Call) Run(run func(ctx context.Context, request *client.QueryWorkflowWithOptionsRequest)) *MockClient_QueryWorkflowWithOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*client.QueryWorkflowWithOptionsRequest))
	})
	return _c
}

func (_c *MockClient_QueryWorkflowWithOptions_Call) Return(_a0 *client.QueryWorkflowWithOptionsResponse, _a1 error) *MockClient_QueryWorkflowWithOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_QueryWorkflowWithOptions_Call) RunAndReturn(run func(context.Context, *client.QueryWorkflowWithOptionsRequest) (*client.QueryWorkflowWithOptionsResponse, error)) *MockClient_QueryWorkflowWithOptions_Call {
	_c.Call.Return(run)
	return _c
}

// RecordActivityHeartbeat provides a mock function with given fields: ctx, taskToken, details
func (_m *MockClient) RecordActivityHeartbeat(ctx context.Context, taskToken []byte, details ...interface{}) error {
	var _ca []interface{}
	_ca = append(_ca, ctx, taskToken)
	_ca = append(_ca, details...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RecordActivityHeartbeat")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []byte, ...interface{}) error); ok {
		r0 = rf(ctx, taskToken, details...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockClient_RecordActivityHeartbeat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordActivityHeartbeat'
type MockClient_RecordActivityHeartbeat_Call struct {
	*mock.Call
}

// RecordActivityHeartbeat is a helper method to define mock.On call
//   - ctx context.Context
//   - taskToken []byte
//   - details ...interface{}
func (_e *MockClient_Expecter) RecordActivityHeartbeat(ctx interface{}, taskToken interface{}, details ...interface{}) *MockClient_RecordActivityHeartbeat_Call {
	return &MockClient_RecordActivityHeartbeat_Call{Call: _e.mock.On("RecordActivityHeartbeat",
		append([]interface{}{ctx, taskToken}, details...)...)}
}

func (_c *MockClient_RecordActivityHeartbeat_Call) Run(run func(ctx context.Context, taskToken []byte, details ...interface{})) *MockClient_RecordActivityHeartbeat_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]interface{}, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		run(args[0].(context.Context), args[1].([]byte), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_RecordActivityHeartbeat_Call) Return(_a0 error) *MockClient_RecordActivityHeartbeat_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_RecordActivityHeartbeat_Call) RunAndReturn(run func(context.Context, []byte, ...interface{}) error) *MockClient_RecordActivityHeartbeat_Call {
	_c.Call.Return(run)
	return _c
}

// RecordActivityHeartbeatByID provides a mock function with given fields: ctx, namespace, workflowID, runID, activityID, details
func (_m *MockClient) RecordActivityHeartbeatByID(ctx context.Context, namespace string, workflowID string, runID string, activityID string, details ...interface{}) error {
	var _ca []interface{}
	_ca = append(_ca, ctx, namespace, workflowID, runID, activityID)
	_ca = append(_ca, details...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RecordActivityHeartbeatByID")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, ...interface{}) error); ok {
		r0 = rf(ctx, namespace, workflowID, runID, activityID, details...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockClient_RecordActivityHeartbeatByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordActivityHeartbeatByID'
type MockClient_RecordActivityHeartbeatByID_Call struct {
	*mock.Call
}

// RecordActivityHeartbeatByID is a helper method to define mock.On call
//   - ctx context.Context
//   - namespace string
//   - workflowID string
//   - runID string
//   - activityID string
//   - details ...interface{}
func (_e *MockClient_Expecter) RecordActivityHeartbeatByID(ctx interface{}, namespace interface{}, workflowID interface{}, runID interface{}, activityID interface{}, details ...interface{}) *MockClient_RecordActivityHeartbeatByID_Call {
	return &MockClient_RecordActivityHeartbeatByID_Call{Call: _e.mock.On("RecordActivityHeartbeatByID",
		append([]interface{}{ctx, namespace, workflowID, runID, activityID}, details...)...)}
}

func (_c *MockClient_RecordActivityHeartbeatByID_Call) Run(run func(ctx context.Context, namespace string, workflowID string, runID string, activityID string, details ...interface{})) *MockClient_RecordActivityHeartbeatByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]interface{}, len(args)-5)
		for i, a := range args[5:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_RecordActivityHeartbeatByID_Call) Return(_a0 error) *MockClient_RecordActivityHeartbeatByID_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_RecordActivityHeartbeatByID_Call) RunAndReturn(run func(context.Context, string, string, string, string, ...interface{}) error) *MockClient_RecordActivityHeartbeatByID_Call {
	_c.Call.Return(run)
	return _c
}

// ResetWorkflowExecution provides a mock function with given fields: ctx, request
func (_m *MockClient) ResetWorkflowExecution(ctx context.Context, request *workflowservice.ResetWorkflowExecutionRequest) (*workflowservice.ResetWorkflowExecutionResponse, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for ResetWorkflowExecution")
	}

	var r0 *workflowservice.ResetWorkflowExecutionResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ResetWorkflowExecutionRequest) (*workflowservice.ResetWorkflowExecutionResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ResetWorkflowExecutionRequest) *workflowservice.ResetWorkflowExecutionResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*workflowservice.ResetWorkflowExecutionResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *workflowservice.ResetWorkflowExecutionRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ResetWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetWorkflowExecution'
type MockClient_ResetWorkflowExecution_Call struct {
	*mock.Call
}

// ResetWorkflowExecution is a helper method to define mock.On call
//   - ctx context.Context
//   - request *workflowservice.ResetWorkflowExecutionRequest
func (_e *MockClient_Expecter) ResetWorkflowExecution(ctx interface{}, request interface{}) *MockClient_ResetWorkflowExecution_Call {
	return &MockClient_ResetWorkflowExecution_Call{Call: _e.mock.On("ResetWorkflowExecution", ctx, request)}
}

func (_c *MockClient_ResetWorkflowExecution_Call) Run(run func(ctx context.Context, request *workflowservice.ResetWorkflowExecutionRequest)) *MockClient_ResetWorkflowExecution_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*workflowservice.ResetWorkflowExecutionRequest))
	})
	return _c
}

func (_c *MockClient_ResetWorkflowExecution_Call) Return(_a0 *workflowservice.ResetWorkflowExecutionResponse, _a1 error) *MockClient_ResetWorkflowExecution_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ResetWorkflowExecution_Call) RunAndReturn(run func(context.Context, *workflowservice.ResetWorkflowExecutionRequest) (*workflowservice.ResetWorkflowExecutionResponse, error)) *MockClient_ResetWorkflowExecution_Call {
	_c.Call.Return(run)
	return _c
}

// ScanWorkflow provides a mock function with given fields: ctx, request
func (_m *MockClient) ScanWorkflow(ctx context.Context, request *workflowservice.ScanWorkflowExecutionsRequest) (*workflowservice.ScanWorkflowExecutionsResponse, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for ScanWorkflow")
	}

	var r0 *workflowservice.ScanWorkflowExecutionsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ScanWorkflowExecutionsRequest) (*workflowservice.ScanWorkflowExecutionsResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *workflowservice.ScanWorkflowExecutionsRequest) *workflowservice.ScanWorkflowExecutionsResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*workflowservice.ScanWorkflowExecutionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *workflowservice.ScanWorkflowExecutionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_ScanWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScanWorkflow'
type MockClient_ScanWorkflow_Call struct {
	*mock.Call
}

// ScanWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - request *workflowservice.ScanWorkflowExecutionsRequest
func (_e *MockClient_Expecter) ScanWorkflow(ctx interface{}, request interface{}) *MockClient_ScanWorkflow_Call {
	return &MockClient_ScanWorkflow_Call{Call: _e.mock.On("ScanWorkflow", ctx, request)}
}

func (_c *MockClient_ScanWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.ScanWorkflowExecutionsRequest)) *MockClient_ScanWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*workflowservice.ScanWorkflowExecutionsRequest))
	})
	return _c
}

func (_c *MockClient_ScanWorkflow_Call) Return(_a0 *workflowservice.ScanWorkflowExecutionsResponse, _a1 error) *MockClient_ScanWorkflow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_ScanWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.ScanWorkflowExecutionsRequest) (*workflowservice.ScanWorkflowExecutionsResponse, error)) *MockClient_ScanWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// ScheduleClient provides a mock function with no fields
func (_m *MockClient) ScheduleClient() client.ScheduleClient {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for ScheduleClient")
	}

	var r0 client.ScheduleClient
	if rf, ok := ret.Get(0).(func() client.ScheduleClient); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(client.ScheduleClient)
		}
	}

	return r0
}

// MockClient_ScheduleClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScheduleClient'
type MockClient_ScheduleClient_Call struct {
	*mock.Call
}

// ScheduleClient is a helper method to define mock.On call
func (_e *MockClient_Expecter) ScheduleClient() *MockClient_ScheduleClient_Call {
	return &MockClient_ScheduleClient_Call{Call: _e.mock.On("ScheduleClient")}
}

func (_c *MockClient_ScheduleClient_Call) Run(run func()) *MockClient_ScheduleClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockClient_ScheduleClient_Call) Return(_a0 client.ScheduleClient) *MockClient_ScheduleClient_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_ScheduleClient_Call) RunAndReturn(run func() client.ScheduleClient) *MockClient_ScheduleClient_Call {
	_c.Call.Return(run)
	return _c
}

// SignalWithStartWorkflow provides a mock function with given fields: ctx, workflowID, signalName, signalArg, options, workflow, workflowArgs
func (_m *MockClient) SignalWithStartWorkflow(ctx context.Context, workflowID string, signalName string, signalArg interface{}, options client.StartWorkflowOptions, workflow interface{}, workflowArgs ...interface{}) (client.WorkflowRun, error) {
	var _ca []interface{}
	_ca = append(_ca, ctx, workflowID, signalName, signalArg, options, workflow)
	_ca = append(_ca, workflowArgs...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for SignalWithStartWorkflow")
	}

	var r0 client.WorkflowRun
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, interface{}, client.StartWorkflowOptions, interface{}, ...interface{}) (client.WorkflowRun, error)); ok {
		return rf(ctx, workflowID, signalName, signalArg, options, workflow, workflowArgs...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, interface{}, client.StartWorkflowOptions, interface{}, ...interface{}) client.WorkflowRun); ok {
		r0 = rf(ctx, workflowID, signalName, signalArg, options, workflow, workflowArgs...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(client.WorkflowRun)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, interface{}, client.StartWorkflowOptions, interface{}, ...interface{}) error); ok {
		r1 = rf(ctx, workflowID, signalName, signalArg, options, workflow, workflowArgs...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_SignalWithStartWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignalWithStartWorkflow'
type MockClient_SignalWithStartWorkflow_Call struct {
	*mock.Call
}

// SignalWithStartWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - workflowID string
//   - signalName string
//   - signalArg interface{}
//   - options client.StartWorkflowOptions
//   - workflow interface{}
//   - workflowArgs ...interface{}
func (_e *MockClient_Expecter) SignalWithStartWorkflow(ctx interface{}, workflowID interface{}, signalName interface{}, signalArg interface{}, options interface{}, workflow interface{}, workflowArgs ...interface{}) *MockClient_SignalWithStartWorkflow_Call {
	return &MockClient_SignalWithStartWorkflow_Call{Call: _e.mock.On("SignalWithStartWorkflow",
		append([]interface{}{ctx, workflowID, signalName, signalArg, options, workflow}, workflowArgs...)...)}
}

func (_c *MockClient_SignalWithStartWorkflow_Call) Run(run func(ctx context.Context, workflowID string, signalName string, signalArg interface{}, options client.StartWorkflowOptions, workflow interface{}, workflowArgs ...interface{})) *MockClient_SignalWithStartWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]interface{}, len(args)-6)
		for i, a := range args[6:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(interface{}), args[4].(client.StartWorkflowOptions), args[5].(interface{}), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_SignalWithStartWorkflow_Call) Return(_a0 client.WorkflowRun, _a1 error) *MockClient_SignalWithStartWorkflow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_SignalWithStartWorkflow_Call) RunAndReturn(run func(context.Context, string, string, interface{}, client.StartWorkflowOptions, interface{}, ...interface{}) (client.WorkflowRun, error)) *MockClient_SignalWithStartWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// SignalWorkflow provides a mock function with given fields: ctx, workflowID, runID, signalName, arg
func (_m *MockClient) SignalWorkflow(ctx context.Context, workflowID string, runID string, signalName string, arg interface{}) error {
	ret := _m.Called(ctx, workflowID, runID, signalName, arg)

	if len(ret) == 0 {
		panic("no return value specified for SignalWorkflow")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, interface{}) error); ok {
		r0 = rf(ctx, workflowID, runID, signalName, arg)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockClient_SignalWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignalWorkflow'
type MockClient_SignalWorkflow_Call struct {
	*mock.Call
}

// SignalWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - workflowID string
//   - runID string
//   - signalName string
//   - arg interface{}
func (_e *MockClient_Expecter) SignalWorkflow(ctx interface{}, workflowID interface{}, runID interface{}, signalName interface{}, arg interface{}) *MockClient_SignalWorkflow_Call {
	return &MockClient_SignalWorkflow_Call{Call: _e.mock.On("SignalWorkflow", ctx, workflowID, runID, signalName, arg)}
}

func (_c *MockClient_SignalWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string, signalName string, arg interface{})) *MockClient_SignalWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(interface{}))
	})
	return _c
}

func (_c *MockClient_SignalWorkflow_Call) Return(_a0 error) *MockClient_SignalWorkflow_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_SignalWorkflow_Call) RunAndReturn(run func(context.Context, string, string, string, interface{}) error) *MockClient_SignalWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// TerminateWorkflow provides a mock function with given fields: ctx, workflowID, runID, reason, details
func (_m *MockClient) TerminateWorkflow(ctx context.Context, workflowID string, runID string, reason string, details ...interface{}) error {
	var _ca []interface{}
	_ca = append(_ca, ctx, workflowID, runID, reason)
	_ca = append(_ca, details...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for TerminateWorkflow")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, ...interface{}) error); ok {
		r0 = rf(ctx, workflowID, runID, reason, details...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockClient_TerminateWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TerminateWorkflow'
type MockClient_TerminateWorkflow_Call struct {
	*mock.Call
}

// TerminateWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - workflowID string
//   - runID string
//   - reason string
//   - details ...interface{}
func (_e *MockClient_Expecter) TerminateWorkflow(ctx interface{}, workflowID interface{}, runID interface{}, reason interface{}, details ...interface{}) *MockClient_TerminateWorkflow_Call {
	return &MockClient_TerminateWorkflow_Call{Call: _e.mock.On("TerminateWorkflow",
		append([]interface{}{ctx, workflowID, runID, reason}, details...)...)}
}

func (_c *MockClient_TerminateWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string, reason string, details ...interface{})) *MockClient_TerminateWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]interface{}, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_TerminateWorkflow_Call) Return(_a0 error) *MockClient_TerminateWorkflow_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_TerminateWorkflow_Call) RunAndReturn(run func(context.Context, string, string, string, ...interface{}) error) *MockClient_TerminateWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateWithStartWorkflow provides a mock function with given fields: ctx, options
func (_m *MockClient) UpdateWithStartWorkflow(ctx context.Context, options client.UpdateWithStartWorkflowOptions) (client.WorkflowUpdateHandle, error) {
	ret := _m.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for UpdateWithStartWorkflow")
	}

	var r0 client.WorkflowUpdateHandle
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWithStartWorkflowOptions) (client.WorkflowUpdateHandle, error)); ok {
		return rf(ctx, options)
	}
	if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWithStartWorkflowOptions) client.WorkflowUpdateHandle); ok {
		r0 = rf(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(client.WorkflowUpdateHandle)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, client.UpdateWithStartWorkflowOptions) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_UpdateWithStartWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWithStartWorkflow'
type MockClient_UpdateWithStartWorkflow_Call struct {
	*mock.Call
}

// UpdateWithStartWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - options client.UpdateWithStartWorkflowOptions
func (_e *MockClient_Expecter) UpdateWithStartWorkflow(ctx interface{}, options interface{}) *MockClient_UpdateWithStartWorkflow_Call {
	return &MockClient_UpdateWithStartWorkflow_Call{Call: _e.mock.On("UpdateWithStartWorkflow", ctx, options)}
}

func (_c *MockClient_UpdateWithStartWorkflow_Call) Run(run func(ctx context.Context, options client.UpdateWithStartWorkflowOptions)) *MockClient_UpdateWithStartWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(client.UpdateWithStartWorkflowOptions))
	})
	return _c
}

func (_c *MockClient_UpdateWithStartWorkflow_Call) Return(_a0 client.WorkflowUpdateHandle, _a1 error) *MockClient_UpdateWithStartWorkflow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_UpdateWithStartWorkflow_Call) RunAndReturn(run func(context.Context, client.UpdateWithStartWorkflowOptions) (client.WorkflowUpdateHandle, error)) *MockClient_UpdateWithStartWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateWorkerBuildIdCompatibility provides a mock function with given fields: ctx, options
func (_m *MockClient) UpdateWorkerBuildIdCompatibility(ctx context.Context, options *client.UpdateWorkerBuildIdCompatibilityOptions) error {
	ret := _m.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for UpdateWorkerBuildIdCompatibility")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *client.UpdateWorkerBuildIdCompatibilityOptions) error); ok {
		r0 = rf(ctx, options)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockClient_UpdateWorkerBuildIdCompatibility_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWorkerBuildIdCompatibility'
type MockClient_UpdateWorkerBuildIdCompatibility_Call struct {
	*mock.Call
}

// UpdateWorkerBuildIdCompatibility is a helper method to define mock.On call
//   - ctx context.Context
//   - options *client.UpdateWorkerBuildIdCompatibilityOptions
func (_e *MockClient_Expecter) UpdateWorkerBuildIdCompatibility(ctx interface{}, options interface{}) *MockClient_UpdateWorkerBuildIdCompatibility_Call {
	return &MockClient_UpdateWorkerBuildIdCompatibility_Call{Call: _e.mock.On("UpdateWorkerBuildIdCompatibility", ctx, options)}
}

func (_c *MockClient_UpdateWorkerBuildIdCompatibility_Call) Run(run func(ctx context.Context, options *client.UpdateWorkerBuildIdCompatibilityOptions)) *MockClient_UpdateWorkerBuildIdCompatibility_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*client.UpdateWorkerBuildIdCompatibilityOptions))
	})
	return _c
}

func (_c *MockClient_UpdateWorkerBuildIdCompatibility_Call) Return(_a0 error) *MockClient_UpdateWorkerBuildIdCompatibility_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_UpdateWorkerBuildIdCompatibility_Call) RunAndReturn(run func(context.Context, *client.UpdateWorkerBuildIdCompatibilityOptions) error) *MockClient_UpdateWorkerBuildIdCompatibility_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateWorkerVersioningRules provides a mock function with given fields: ctx, options
func (_m *MockClient) UpdateWorkerVersioningRules(ctx context.Context, options client.UpdateWorkerVersioningRulesOptions) (*client.WorkerVersioningRules, error) {
	ret := _m.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for UpdateWorkerVersioningRules")
	}

	var r0 *client.WorkerVersioningRules
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWorkerVersioningRulesOptions) (*client.WorkerVersioningRules, error)); ok {
		return rf(ctx, options)
	}
	if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWorkerVersioningRulesOptions) *client.WorkerVersioningRules); ok {
		r0 = rf(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.WorkerVersioningRules)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, client.UpdateWorkerVersioningRulesOptions) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_UpdateWorkerVersioningRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWorkerVersioningRules'
type MockClient_UpdateWorkerVersioningRules_Call struct {
	*mock.Call
}

// UpdateWorkerVersioningRules is a helper method to define mock.On call
//   - ctx context.Context
//   - options client.UpdateWorkerVersioningRulesOptions
func (_e *MockClient_Expecter) UpdateWorkerVersioningRules(ctx interface{}, options interface{}) *MockClient_UpdateWorkerVersioningRules_Call {
	return &MockClient_UpdateWorkerVersioningRules_Call{Call: _e.mock.On("UpdateWorkerVersioningRules", ctx, options)}
}

func (_c *MockClient_UpdateWorkerVersioningRules_Call) Run(run func(ctx context.Context, options client.UpdateWorkerVersioningRulesOptions)) *MockClient_UpdateWorkerVersioningRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(client.UpdateWorkerVersioningRulesOptions))
	})
	return _c
}

func (_c *MockClient_UpdateWorkerVersioningRules_Call) Return(_a0 *client.WorkerVersioningRules, _a1 error) *MockClient_UpdateWorkerVersioningRules_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_UpdateWorkerVersioningRules_Call) RunAndReturn(run func(context.Context, client.UpdateWorkerVersioningRulesOptions) (*client.WorkerVersioningRules, error)) *MockClient_UpdateWorkerVersioningRules_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateWorkflow provides a mock function with given fields: ctx, options
func (_m *MockClient) UpdateWorkflow(ctx context.Context, options client.UpdateWorkflowOptions) (client.WorkflowUpdateHandle, error) {
	ret := _m.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for UpdateWorkflow")
	}

	var r0 client.WorkflowUpdateHandle
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWorkflowOptions) (client.WorkflowUpdateHandle, error)); ok {
		return rf(ctx, options)
	}
	if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWorkflowOptions) client.WorkflowUpdateHandle); ok {
		r0 = rf(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(client.WorkflowUpdateHandle)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, client.UpdateWorkflowOptions) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_UpdateWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWorkflow'
type MockClient_UpdateWorkflow_Call struct {
	*mock.Call
}

// UpdateWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - options client.UpdateWorkflowOptions
func (_e *MockClient_Expecter) UpdateWorkflow(ctx interface{}, options interface{}) *MockClient_UpdateWorkflow_Call {
	return &MockClient_UpdateWorkflow_Call{Call: _e.mock.On("UpdateWorkflow", ctx, options)}
}

func (_c *MockClient_UpdateWorkflow_Call) Run(run func(ctx context.Context, options client.UpdateWorkflowOptions)) *MockClient_UpdateWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(client.UpdateWorkflowOptions))
	})
	return _c
}

func (_c *MockClient_UpdateWorkflow_Call) Return(_a0 client.WorkflowUpdateHandle, _a1 error) *MockClient_UpdateWorkflow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_UpdateWorkflow_Call) RunAndReturn(run func(context.Context, client.UpdateWorkflowOptions) (client.WorkflowUpdateHandle, error)) *MockClient_UpdateWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateWorkflowExecutionOptions provides a mock function with given fields: ctx, options
func (_m *MockClient) UpdateWorkflowExecutionOptions(ctx context.Context, options client.UpdateWorkflowExecutionOptionsRequest) (client.WorkflowExecutionOptions, error) {
	ret := _m.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for UpdateWorkflowExecutionOptions")
	}

	var r0 client.WorkflowExecutionOptions
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWorkflowExecutionOptionsRequest) (client.WorkflowExecutionOptions, error)); ok {
		return rf(ctx, options)
	}
	if rf, ok := ret.Get(0).(func(context.Context, client.UpdateWorkflowExecutionOptionsRequest) client.WorkflowExecutionOptions); ok {
		r0 = rf(ctx, options)
	} else {
		r0 = ret.Get(0).(client.WorkflowExecutionOptions)
	}

	if rf, ok := ret.Get(1).(func(context.Context, client.UpdateWorkflowExecutionOptionsRequest) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockClient_UpdateWorkflowExecutionOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWorkflowExecutionOptions'
type MockClient_UpdateWorkflowExecutionOptions_Call struct {
	*mock.Call
}

// UpdateWorkflowExecutionOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - options client.UpdateWorkflowExecutionOptionsRequest
func (_e *MockClient_Expecter) UpdateWorkflowExecutionOptions(ctx interface{}, options interface{}) *MockClient_UpdateWorkflowExecutionOptions_Call {
	return &MockClient_UpdateWorkflowExecutionOptions_Call{Call: _e.mock.On("UpdateWorkflowExecutionOptions", ctx, options)}
}

func (_c *MockClient_UpdateWorkflowExecutionOptions_Call) Run(run func(ctx context.Context, options client.UpdateWorkflowExecutionOptionsRequest)) *MockClient_UpdateWorkflowExecutionOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(client.UpdateWorkflowExecutionOptionsRequest))
	})
	return _c
}

func (_c *MockClient_UpdateWorkflowExecutionOptions_Call) Return(_a0 client.WorkflowExecutionOptions, _a1 error) *MockClient_UpdateWorkflowExecutionOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_UpdateWorkflowExecutionOptions_Call) RunAndReturn(run func(context.Context, client.UpdateWorkflowExecutionOptionsRequest) (client.WorkflowExecutionOptions, error)) *MockClient_UpdateWorkflowExecutionOptions_Call {
	_c.Call.Return(run)
	return _c
}

// WorkerDeploymentClient provides a mock function with no fields
func (_m *MockClient) WorkerDeploymentClient() client.WorkerDeploymentClient {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for WorkerDeploymentClient")
	}

	var r0 client.WorkerDeploymentClient
	if rf, ok := ret.Get(0).(func() client.WorkerDeploymentClient); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(client.WorkerDeploymentClient)
		}
	}

	return r0
}

// MockClient_WorkerDeploymentClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WorkerDeploymentClient'
type MockClient_WorkerDeploymentClient_Call struct {
	*mock.Call
}

// WorkerDeploymentClient is a helper method to define mock.On call
func (_e *MockClient_Expecter) WorkerDeploymentClient() *MockClient_WorkerDeploymentClient_Call {
	return &MockClient_WorkerDeploymentClient_Call{Call: _e.mock.On("WorkerDeploymentClient")}
}

func (_c *MockClient_WorkerDeploymentClient_Call) Run(run func()) *MockClient_WorkerDeploymentClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockClient_WorkerDeploymentClient_Call) Return(_a0 client.WorkerDeploymentClient) *MockClient_WorkerDeploymentClient_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_WorkerDeploymentClient_Call) RunAndReturn(run func() client.WorkerDeploymentClient) *MockClient_WorkerDeploymentClient_Call {
	_c.Call.Return(run)
	return _c
}

// WorkflowService provides a mock function with no fields
func (_m *MockClient) WorkflowService() workflowservice.WorkflowServiceClient {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for WorkflowService")
	}

	var r0 workflowservice.WorkflowServiceClient
	if rf, ok := ret.Get(0).(func() workflowservice.WorkflowServiceClient); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(workflowservice.WorkflowServiceClient)
		}
	}

	return r0
}

// MockClient_WorkflowService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WorkflowService'
type MockClient_WorkflowService_Call struct {
	*mock.Call
}

// WorkflowService is a helper method to define mock.On call
func (_e *MockClient_Expecter) WorkflowService() *MockClient_WorkflowService_Call {
	return &MockClient_WorkflowService_Call{Call: _e.mock.On("WorkflowService")}
}

func (_c *MockClient_WorkflowService_Call) Run(run func()) *MockClient_WorkflowService_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockClient_WorkflowService_Call) Return(_a0 workflowservice.WorkflowServiceClient) *MockClient_WorkflowService_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClient_WorkflowService_Call) RunAndReturn(run func() workflowservice.WorkflowServiceClient) *MockClient_WorkflowService_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockClient creates a new instance of MockClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockClient {
	mock := &MockClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}