// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package examplev1mocks

import (
	"context"

	"github.com/cludden/protoc-gen-go-temporal/gen/example/v1"
	mock "github.com/stretchr/testify/mock"
	"go.temporal.io/sdk/client"
)

// NewMockExampleClient creates a new instance of MockExampleClient. 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 NewMockExampleClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockExampleClient {
	mock := &MockExampleClient{}
	mock.Mock.Test(t)

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

	return mock
}

// MockExampleClient is an autogenerated mock type for the ExampleClient type
type MockExampleClient struct {
	mock.Mock
}

type MockExampleClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockExampleClient) EXPECT() *MockExampleClient_Expecter {
	return &MockExampleClient_Expecter{mock: &_m.Mock}
}

// CancelWorkflow provides a mock function for the type MockExampleClient
func (_mock *MockExampleClient) CancelWorkflow(ctx context.Context, workflowID string, runID string) error {
	ret := _mock.Called(ctx, workflowID, runID)

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

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

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

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

func (_c *MockExampleClient_CancelWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string)) *MockExampleClient_CancelWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockExampleClient_CancelWorkflow_Call) Return(err error) *MockExampleClient_CancelWorkflow_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockExampleClient_CancelWorkflow_Call) RunAndReturn(run func(ctx context.Context, workflowID string, runID string) error) *MockExampleClient_CancelWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFoo provides a mock function for the type MockExampleClient
func (_mock *MockExampleClient) CreateFoo(ctx context.Context, req *examplev1.CreateFooRequest, opts ...*examplev1.CreateFooOptions) (*examplev1.CreateFooResponse, error) {
	// *examplev1.CreateFooOptions
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, req)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *examplev1.CreateFooResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *examplev1.CreateFooRequest, ...*examplev1.CreateFooOptions) (*examplev1.CreateFooResponse, error)); ok {
		return returnFunc(ctx, req, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *examplev1.CreateFooRequest, ...*examplev1.CreateFooOptions) *examplev1.CreateFooResponse); ok {
		r0 = returnFunc(ctx, req, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*examplev1.CreateFooResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *examplev1.CreateFooRequest, ...*examplev1.CreateFooOptions) error); ok {
		r1 = returnFunc(ctx, req, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateFoo is a helper method to define mock.On call
//   - ctx context.Context
//   - req *examplev1.CreateFooRequest
//   - opts ...*examplev1.CreateFooOptions
func (_e *MockExampleClient_Expecter) CreateFoo(ctx interface{}, req interface{}, opts ...interface{}) *MockExampleClient_CreateFoo_Call {
	return &MockExampleClient_CreateFoo_Call{Call: _e.mock.On("CreateFoo",
		append([]interface{}{ctx, req}, opts...)...)}
}

func (_c *MockExampleClient_CreateFoo_Call) Run(run func(ctx context.Context, req *examplev1.CreateFooRequest, opts ...*examplev1.CreateFooOptions)) *MockExampleClient_CreateFoo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *examplev1.CreateFooRequest
		if args[1] != nil {
			arg1 = args[1].(*examplev1.CreateFooRequest)
		}
		var arg2 []*examplev1.CreateFooOptions
		variadicArgs := make([]*examplev1.CreateFooOptions, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(*examplev1.CreateFooOptions)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *MockExampleClient_CreateFoo_Call) Return(createFooResponse *examplev1.CreateFooResponse, err error) *MockExampleClient_CreateFoo_Call {
	_c.Call.Return(createFooResponse, err)
	return _c
}

func (_c *MockExampleClient_CreateFoo_Call) RunAndReturn(run func(ctx context.Context, req *examplev1.CreateFooRequest, opts ...*examplev1.CreateFooOptions) (*examplev1.CreateFooResponse, error)) *MockExampleClient_CreateFoo_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFooAsync provides a mock function for the type MockExampleClient
func (_mock *MockExampleClient) CreateFooAsync(ctx context.Context, req *examplev1.CreateFooRequest, opts ...*examplev1.CreateFooOptions) (examplev1.CreateFooRun, error) {
	// *examplev1.CreateFooOptions
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, req)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 examplev1.CreateFooRun
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *examplev1.CreateFooRequest, ...*examplev1.CreateFooOptions) (examplev1.CreateFooRun, error)); ok {
		return returnFunc(ctx, req, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *examplev1.CreateFooRequest, ...*examplev1.CreateFooOptions) examplev1.CreateFooRun); ok {
		r0 = returnFunc(ctx, req, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(examplev1.CreateFooRun)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *examplev1.CreateFooRequest, ...*examplev1.CreateFooOptions) error); ok {
		r1 = returnFunc(ctx, req, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateFooAsync is a helper method to define mock.On call
//   - ctx context.Context
//   - req *examplev1.CreateFooRequest
//   - opts ...*examplev1.CreateFooOptions
func (_e *MockExampleClient_Expecter) CreateFooAsync(ctx interface{}, req interface{}, opts ...interface{}) *MockExampleClient_CreateFooAsync_Call {
	return &MockExampleClient_CreateFooAsync_Call{Call: _e.mock.On("CreateFooAsync",
		append([]interface{}{ctx, req}, opts...)...)}
}

func (_c *MockExampleClient_CreateFooAsync_Call) Run(run func(ctx context.Context, req *examplev1.CreateFooRequest, opts ...*examplev1.CreateFooOptions)) *MockExampleClient_CreateFooAsync_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *examplev1.CreateFooRequest
		if args[1] != nil {
			arg1 = args[1].(*examplev1.CreateFooRequest)
		}
		var arg2 []*examplev1.CreateFooOptions
		variadicArgs := make([]*examplev1.CreateFooOptions, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(*examplev1.CreateFooOptions)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *MockExampleClient_CreateFooAsync_Call) Return(createFooRun examplev1.CreateFooRun, err error) *MockExampleClient_CreateFooAsync_Call {
	_c.Call.Return(createFooRun, err)
	return _c
}

func (_c *MockExampleClient_CreateFooAsync_Call) RunAndReturn(run func(ctx context.Context, req *examplev1.CreateFooRequest, opts ...*examplev1.CreateFooOptions) (examplev1.CreateFooRun, error)) *MockExampleClient_CreateFooAsync_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFooWithSetFooProgress provides a mock function for the type MockExampleClient
func (_mock *MockExampleClient) CreateFooWithSetFooProgress(ctx context.Context, req *examplev1.CreateFooRequest, signal *examplev1.SetFooProgressRequest, opts ...*examplev1.CreateFooOptions) (*examplev1.CreateFooResponse, error) {
	// *examplev1.CreateFooOptions
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, req, signal)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *examplev1.CreateFooResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *examplev1.CreateFooRequest, *examplev1.SetFooProgressRequest, ...*examplev1.CreateFooOptions) (*examplev1.CreateFooResponse, error)); ok {
		return returnFunc(ctx, req, signal, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *examplev1.CreateFooRequest, *examplev1.SetFooProgressRequest, ...*examplev1.CreateFooOptions) *examplev1.CreateFooResponse); ok {
		r0 = returnFunc(ctx, req, signal, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*examplev1.CreateFooResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *examplev1.CreateFooRequest, *examplev1.SetFooProgressRequest, ...*examplev1.CreateFooOptions) error); ok {
		r1 = returnFunc(ctx, req, signal, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateFooWithSetFooProgress is a helper method to define mock.On call
//   - ctx context.Context
//   - req *examplev1.CreateFooRequest
//   - signal *examplev1.SetFooProgressRequest
//   - opts ...*examplev1.CreateFooOptions
func (_e *MockExampleClient_Expecter) CreateFooWithSetFooProgress(ctx interface{}, req interface{}, signal interface{}, opts ...interface{}) *MockExampleClient_CreateFooWithSetFooProgress_Call {
	return &MockExampleClient_CreateFooWithSetFooProgress_Call{Call: _e.mock.On("CreateFooWithSetFooProgress",
		append([]interface{}{ctx, req, signal}, opts...)...)}
}

func (_c *MockExampleClient_CreateFooWithSetFooProgress_Call) Run(run func(ctx context.Context, req *examplev1.CreateFooRequest, signal *examplev1.SetFooProgressRequest, opts ...*examplev1.CreateFooOptions)) *MockExampleClient_CreateFooWithSetFooProgress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *examplev1.CreateFooRequest
		if args[1] != nil {
			arg1 = args[1].(*examplev1.CreateFooRequest)
		}
		var arg2 *examplev1.SetFooProgressRequest
		if args[2] != nil {
			arg2 = args[2].(*examplev1.SetFooProgressRequest)
		}
		var arg3 []*examplev1.CreateFooOptions
		variadicArgs := make([]*examplev1.CreateFooOptions, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(*examplev1.CreateFooOptions)
			}
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

func (_c *MockExampleClient_CreateFooWithSetFooProgress_Call) Return(createFooResponse *examplev1.CreateFooResponse, err error) *MockExampleClient_CreateFooWithSetFooProgress_Call {
	_c.Call.Return(createFooResponse, err)
	return _c
}

func (_c *MockExampleClient_CreateFooWithSetFooProgress_Call) RunAndReturn(run func(ctx context.Context, req *examplev1.CreateFooRequest, signal *examplev1.SetFooProgressRequest, opts ...*examplev1.CreateFooOptions) (*examplev1.CreateFooResponse, error)) *MockExampleClient_CreateFooWithSetFooProgress_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFooWithSetFooProgressAsync provides a mock function for the type MockExampleClient
func (_mock *MockExampleClient) CreateFooWithSetFooProgressAsync(ctx context.Context, req *examplev1.CreateFooRequest, signal *examplev1.SetFooProgressRequest, opts ...*examplev1.CreateFooOptions) (examplev1.CreateFooRun, error) {
	// *examplev1.CreateFooOptions
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, req, signal)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 examplev1.CreateFooRun
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *examplev1.CreateFooRequest, *examplev1.SetFooProgressRequest, ...*examplev1.CreateFooOptions) (examplev1.CreateFooRun, error)); ok {
		return returnFunc(ctx, req, signal, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *examplev1.CreateFooRequest, *examplev1.SetFooProgressRequest, ...*examplev1.CreateFooOptions) examplev1.CreateFooRun); ok {
		r0 = returnFunc(ctx, req, signal, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(examplev1.CreateFooRun)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *examplev1.CreateFooRequest, *examplev1.SetFooProgressRequest, ...*examplev1.CreateFooOptions) error); ok {
		r1 = returnFunc(ctx, req, signal, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateFooWithSetFooProgressAsync is a helper method to define mock.On call
//   - ctx context.Context
//   - req *examplev1.CreateFooRequest
//   - signal *examplev1.SetFooProgressRequest
//   - opts ...*examplev1.CreateFooOptions
func (_e *MockExampleClient_Expecter) CreateFooWithSetFooProgressAsync(ctx interface{}, req interface{}, signal interface{}, opts ...interface{}) *MockExampleClient_CreateFooWithSetFooProgressAsync_Call {
	return &MockExampleClient_CreateFooWithSetFooProgressAsync_Call{Call: _e.mock.On("CreateFooWithSetFooProgressAsync",
		append([]interface{}{ctx, req, signal}, opts...)...)}
}

func (_c *MockExampleClient_CreateFooWithSetFooProgressAsync_Call) Run(run func(ctx context.Context, req *examplev1.CreateFooRequest, signal *examplev1.SetFooProgressRequest, opts ...*examplev1.CreateFooOptions)) *MockExampleClient_CreateFooWithSetFooProgressAsync_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *examplev1.CreateFooRequest
		if args[1] != nil {
			arg1 = args[1].(*examplev1.CreateFooRequest)
		}
		var arg2 *examplev1.SetFooProgressRequest
		if args[2] != nil {
			arg2 = args[2].(*examplev1.SetFooProgressRequest)
		}
		var arg3 []*examplev1.CreateFooOptions
		variadicArgs := make([]*examplev1.CreateFooOptions, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(*examplev1.CreateFooOptions)
			}
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

func (_c *MockExampleClient_CreateFooWithSetFooProgressAsync_Call) Return(createFooRun examplev1.CreateFooRun, err error) *MockExampleClient_CreateFooWithSetFooProgressAsync_Call {
	_c.Call.Return(createFooRun, err)
	return _c
}

func (_c *MockExampleClient_CreateFooWithSetFooProgressAsync_Call) RunAndReturn(run func(ctx context.Context, req *examplev1.CreateFooRequest, signal *examplev1.SetFooProgressRequest, opts ...*examplev1.CreateFooOptions) (examplev1.CreateFooRun, error)) *MockExampleClient_CreateFooWithSetFooProgressAsync_Call {
	_c.Call.Return(run)
	return _c
}

// GetCreateFoo provides a mock function for the type MockExampleClient
func (_mock *MockExampleClient) GetCreateFoo(ctx context.Context, workflowID string, runID string) examplev1.CreateFooRun {
	ret := _mock.Called(ctx, workflowID, runID)

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

	var r0 examplev1.CreateFooRun
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) examplev1.CreateFooRun); ok {
		r0 = returnFunc(ctx, workflowID, runID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(examplev1.CreateFooRun)
		}
	}
	return r0
}

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

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

func (_c *MockExampleClient_GetCreateFoo_Call) Run(run func(ctx context.Context, workflowID string, runID string)) *MockExampleClient_GetCreateFoo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockExampleClient_GetCreateFoo_Call) Return(createFooRun examplev1.CreateFooRun) *MockExampleClient_GetCreateFoo_Call {
	_c.Call.Return(createFooRun)
	return _c
}

func (_c *MockExampleClient_GetCreateFoo_Call) RunAndReturn(run func(ctx context.Context, workflowID string, runID string) examplev1.CreateFooRun) *MockExampleClient_GetCreateFoo_Call {
	_c.Call.Return(run)
	return _c
}

// GetFooProgress provides a mock function for the type MockExampleClient
func (_mock *MockExampleClient) GetFooProgress(ctx context.Context, workflowID string, runID string) (*examplev1.GetFooProgressResponse, error) {
	ret := _mock.Called(ctx, workflowID, runID)

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

	var r0 *examplev1.GetFooProgressResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*examplev1.GetFooProgressResponse, error)); ok {
		return returnFunc(ctx, workflowID, runID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *examplev1.GetFooProgressResponse); ok {
		r0 = returnFunc(ctx, workflowID, runID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*examplev1.GetFooProgressResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, workflowID, runID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

func (_c *MockExampleClient_GetFooProgress_Call) Run(run func(ctx context.Context, workflowID string, runID string)) *MockExampleClient_GetFooProgress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockExampleClient_GetFooProgress_Call) Return(getFooProgressResponse *examplev1.GetFooProgressResponse, err error) *MockExampleClient_GetFooProgress_Call {
	_c.Call.Return(getFooProgressResponse, err)
	return _c
}

func (_c *MockExampleClient_GetFooProgress_Call) RunAndReturn(run func(ctx context.Context, workflowID string, runID string) (*examplev1.GetFooProgressResponse, error)) *MockExampleClient_GetFooProgress_Call {
	_c.Call.Return(run)
	return _c
}

// GetUpdateFooProgress provides a mock function for the type MockExampleClient
func (_mock *MockExampleClient) GetUpdateFooProgress(ctx context.Context, req client.GetWorkflowUpdateHandleOptions) (examplev1.UpdateFooProgressHandle, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 examplev1.UpdateFooProgressHandle
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, client.GetWorkflowUpdateHandleOptions) (examplev1.UpdateFooProgressHandle, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, client.GetWorkflowUpdateHandleOptions) examplev1.UpdateFooProgressHandle); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(examplev1.UpdateFooProgressHandle)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, client.GetWorkflowUpdateHandleOptions) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetUpdateFooProgress is a helper method to define mock.On call
//   - ctx context.Context
//   - req client.GetWorkflowUpdateHandleOptions
func (_e *MockExampleClient_Expecter) GetUpdateFooProgress(ctx interface{}, req interface{}) *MockExampleClient_GetUpdateFooProgress_Call {
	return &MockExampleClient_GetUpdateFooProgress_Call{Call: _e.mock.On("GetUpdateFooProgress", ctx, req)}
}

func (_c *MockExampleClient_GetUpdateFooProgress_Call) Run(run func(ctx context.Context, req client.GetWorkflowUpdateHandleOptions)) *MockExampleClient_GetUpdateFooProgress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 client.GetWorkflowUpdateHandleOptions
		if args[1] != nil {
			arg1 = args[1].(client.GetWorkflowUpdateHandleOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockExampleClient_GetUpdateFooProgress_Call) Return(updateFooProgressHandle examplev1.UpdateFooProgressHandle, err error) *MockExampleClient_GetUpdateFooProgress_Call {
	_c.Call.Return(updateFooProgressHandle, err)
	return _c
}

func (_c *MockExampleClient_GetUpdateFooProgress_Call) RunAndReturn(run func(ctx context.Context, req client.GetWorkflowUpdateHandleOptions) (examplev1.UpdateFooProgressHandle, error)) *MockExampleClient_GetUpdateFooProgress_Call {
	_c.Call.Return(run)
	return _c
}

// SetFooProgress provides a mock function for the type MockExampleClient
func (_mock *MockExampleClient) SetFooProgress(ctx context.Context, workflowID string, runID string, signal *examplev1.SetFooProgressRequest) error {
	ret := _mock.Called(ctx, workflowID, runID, signal)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *examplev1.SetFooProgressRequest) error); ok {
		r0 = returnFunc(ctx, workflowID, runID, signal)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetFooProgress is a helper method to define mock.On call
//   - ctx context.Context
//   - workflowID string
//   - runID string
//   - signal *examplev1.SetFooProgressRequest
func (_e *MockExampleClient_Expecter) SetFooProgress(ctx interface{}, workflowID interface{}, runID interface{}, signal interface{}) *MockExampleClient_SetFooProgress_Call {
	return &MockExampleClient_SetFooProgress_Call{Call: _e.mock.On("SetFooProgress", ctx, workflowID, runID, signal)}
}

func (_c *MockExampleClient_SetFooProgress_Call) Run(run func(ctx context.Context, workflowID string, runID string, signal *examplev1.SetFooProgressRequest)) *MockExampleClient_SetFooProgress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *examplev1.SetFooProgressRequest
		if args[3] != nil {
			arg3 = args[3].(*examplev1.SetFooProgressRequest)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockExampleClient_SetFooProgress_Call) Return(err error) *MockExampleClient_SetFooProgress_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockExampleClient_SetFooProgress_Call) RunAndReturn(run func(ctx context.Context, workflowID string, runID string, signal *examplev1.SetFooProgressRequest) error) *MockExampleClient_SetFooProgress_Call {
	_c.Call.Return(run)
	return _c
}

// TerminateWorkflow provides a mock function for the type MockExampleClient
func (_mock *MockExampleClient) 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 := _mock.Called(_ca...)

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

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

// MockExampleClient_TerminateWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TerminateWorkflow'
type MockExampleClient_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 *MockExampleClient_Expecter) TerminateWorkflow(ctx interface{}, workflowID interface{}, runID interface{}, reason interface{}, details ...interface{}) *MockExampleClient_TerminateWorkflow_Call {
	return &MockExampleClient_TerminateWorkflow_Call{Call: _e.mock.On("TerminateWorkflow",
		append([]interface{}{ctx, workflowID, runID, reason}, details...)...)}
}

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

func (_c *MockExampleClient_TerminateWorkflow_Call) Return(err error) *MockExampleClient_TerminateWorkflow_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockExampleClient_TerminateWorkflow_Call) RunAndReturn(run func(ctx context.Context, workflowID string, runID string, reason string, details ...interface{}) error) *MockExampleClient_TerminateWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateFooProgress provides a mock function for the type MockExampleClient
func (_mock *MockExampleClient) UpdateFooProgress(ctx context.Context, workflowID string, runID string, req *examplev1.SetFooProgressRequest, opts ...*examplev1.UpdateFooProgressOptions) (*examplev1.GetFooProgressResponse, error) {
	// *examplev1.UpdateFooProgressOptions
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, workflowID, runID, req)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *examplev1.GetFooProgressResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *examplev1.SetFooProgressRequest, ...*examplev1.UpdateFooProgressOptions) (*examplev1.GetFooProgressResponse, error)); ok {
		return returnFunc(ctx, workflowID, runID, req, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *examplev1.SetFooProgressRequest, ...*examplev1.UpdateFooProgressOptions) *examplev1.GetFooProgressResponse); ok {
		r0 = returnFunc(ctx, workflowID, runID, req, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*examplev1.GetFooProgressResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *examplev1.SetFooProgressRequest, ...*examplev1.UpdateFooProgressOptions) error); ok {
		r1 = returnFunc(ctx, workflowID, runID, req, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateFooProgress is a helper method to define mock.On call
//   - ctx context.Context
//   - workflowID string
//   - runID string
//   - req *examplev1.SetFooProgressRequest
//   - opts ...*examplev1.UpdateFooProgressOptions
func (_e *MockExampleClient_Expecter) UpdateFooProgress(ctx interface{}, workflowID interface{}, runID interface{}, req interface{}, opts ...interface{}) *MockExampleClient_UpdateFooProgress_Call {
	return &MockExampleClient_UpdateFooProgress_Call{Call: _e.mock.On("UpdateFooProgress",
		append([]interface{}{ctx, workflowID, runID, req}, opts...)...)}
}

func (_c *MockExampleClient_UpdateFooProgress_Call) Run(run func(ctx context.Context, workflowID string, runID string, req *examplev1.SetFooProgressRequest, opts ...*examplev1.UpdateFooProgressOptions)) *MockExampleClient_UpdateFooProgress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *examplev1.SetFooProgressRequest
		if args[3] != nil {
			arg3 = args[3].(*examplev1.SetFooProgressRequest)
		}
		var arg4 []*examplev1.UpdateFooProgressOptions
		variadicArgs := make([]*examplev1.UpdateFooProgressOptions, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(*examplev1.UpdateFooProgressOptions)
			}
		}
		arg4 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4...,
		)
	})
	return _c
}

func (_c *MockExampleClient_UpdateFooProgress_Call) Return(getFooProgressResponse *examplev1.GetFooProgressResponse, err error) *MockExampleClient_UpdateFooProgress_Call {
	_c.Call.Return(getFooProgressResponse, err)
	return _c
}

func (_c *MockExampleClient_UpdateFooProgress_Call) RunAndReturn(run func(ctx context.Context, workflowID string, runID string, req *examplev1.SetFooProgressRequest, opts ...*examplev1.UpdateFooProgressOptions) (*examplev1.GetFooProgressResponse, error)) *MockExampleClient_UpdateFooProgress_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateFooProgressAsync provides a mock function for the type MockExampleClient
func (_mock *MockExampleClient) UpdateFooProgressAsync(ctx context.Context, workflowID string, runID string, req *examplev1.SetFooProgressRequest, opts ...*examplev1.UpdateFooProgressOptions) (examplev1.UpdateFooProgressHandle, error) {
	// *examplev1.UpdateFooProgressOptions
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, workflowID, runID, req)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 examplev1.UpdateFooProgressHandle
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *examplev1.SetFooProgressRequest, ...*examplev1.UpdateFooProgressOptions) (examplev1.UpdateFooProgressHandle, error)); ok {
		return returnFunc(ctx, workflowID, runID, req, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *examplev1.SetFooProgressRequest, ...*examplev1.UpdateFooProgressOptions) examplev1.UpdateFooProgressHandle); ok {
		r0 = returnFunc(ctx, workflowID, runID, req, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(examplev1.UpdateFooProgressHandle)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *examplev1.SetFooProgressRequest, ...*examplev1.UpdateFooProgressOptions) error); ok {
		r1 = returnFunc(ctx, workflowID, runID, req, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateFooProgressAsync is a helper method to define mock.On call
//   - ctx context.Context
//   - workflowID string
//   - runID string
//   - req *examplev1.SetFooProgressRequest
//   - opts ...*examplev1.UpdateFooProgressOptions
func (_e *MockExampleClient_Expecter) UpdateFooProgressAsync(ctx interface{}, workflowID interface{}, runID interface{}, req interface{}, opts ...interface{}) *MockExampleClient_UpdateFooProgressAsync_Call {
	return &MockExampleClient_UpdateFooProgressAsync_Call{Call: _e.mock.On("UpdateFooProgressAsync",
		append([]interface{}{ctx, workflowID, runID, req}, opts...)...)}
}

func (_c *MockExampleClient_UpdateFooProgressAsync_Call) Run(run func(ctx context.Context, workflowID string, runID string, req *examplev1.SetFooProgressRequest, opts ...*examplev1.UpdateFooProgressOptions)) *MockExampleClient_UpdateFooProgressAsync_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *examplev1.SetFooProgressRequest
		if args[3] != nil {
			arg3 = args[3].(*examplev1.SetFooProgressRequest)
		}
		var arg4 []*examplev1.UpdateFooProgressOptions
		variadicArgs := make([]*examplev1.UpdateFooProgressOptions, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(*examplev1.UpdateFooProgressOptions)
			}
		}
		arg4 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4...,
		)
	})
	return _c
}

func (_c *MockExampleClient_UpdateFooProgressAsync_Call) Return(updateFooProgressHandle examplev1.UpdateFooProgressHandle, err error) *MockExampleClient_UpdateFooProgressAsync_Call {
	_c.Call.Return(updateFooProgressHandle, err)
	return _c
}

func (_c *MockExampleClient_UpdateFooProgressAsync_Call) RunAndReturn(run func(ctx context.Context, workflowID string, runID string, req *examplev1.SetFooProgressRequest, opts ...*examplev1.UpdateFooProgressOptions) (examplev1.UpdateFooProgressHandle, error)) *MockExampleClient_UpdateFooProgressAsync_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockCreateFooRun creates a new instance of MockCreateFooRun. 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 NewMockCreateFooRun(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockCreateFooRun {
	mock := &MockCreateFooRun{}
	mock.Mock.Test(t)

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

	return mock
}

// MockCreateFooRun is an autogenerated mock type for the CreateFooRun type
type MockCreateFooRun struct {
	mock.Mock
}

type MockCreateFooRun_Expecter struct {
	mock *mock.Mock
}

func (_m *MockCreateFooRun) EXPECT() *MockCreateFooRun_Expecter {
	return &MockCreateFooRun_Expecter{mock: &_m.Mock}
}

// Cancel provides a mock function for the type MockCreateFooRun
func (_mock *MockCreateFooRun) Cancel(ctx context.Context) error {
	ret := _mock.Called(ctx)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

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

func (_c *MockCreateFooRun_Cancel_Call) Run(run func(ctx context.Context)) *MockCreateFooRun_Cancel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockCreateFooRun_Cancel_Call) Return(err error) *MockCreateFooRun_Cancel_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockCreateFooRun_Cancel_Call) RunAndReturn(run func(ctx context.Context) error) *MockCreateFooRun_Cancel_Call {
	_c.Call.Return(run)
	return _c
}

// Get provides a mock function for the type MockCreateFooRun
func (_mock *MockCreateFooRun) Get(ctx context.Context) (*examplev1.CreateFooResponse, error) {
	ret := _mock.Called(ctx)

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

	var r0 *examplev1.CreateFooResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (*examplev1.CreateFooResponse, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) *examplev1.CreateFooResponse); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*examplev1.CreateFooResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

func (_c *MockCreateFooRun_Get_Call) Run(run func(ctx context.Context)) *MockCreateFooRun_Get_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockCreateFooRun_Get_Call) Return(createFooResponse *examplev1.CreateFooResponse, err error) *MockCreateFooRun_Get_Call {
	_c.Call.Return(createFooResponse, err)
	return _c
}

func (_c *MockCreateFooRun_Get_Call) RunAndReturn(run func(ctx context.Context) (*examplev1.CreateFooResponse, error)) *MockCreateFooRun_Get_Call {
	_c.Call.Return(run)
	return _c
}

// GetFooProgress provides a mock function for the type MockCreateFooRun
func (_mock *MockCreateFooRun) GetFooProgress(ctx context.Context) (*examplev1.GetFooProgressResponse, error) {
	ret := _mock.Called(ctx)

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

	var r0 *examplev1.GetFooProgressResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (*examplev1.GetFooProgressResponse, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) *examplev1.GetFooProgressResponse); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*examplev1.GetFooProgressResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

func (_c *MockCreateFooRun_GetFooProgress_Call) Run(run func(ctx context.Context)) *MockCreateFooRun_GetFooProgress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockCreateFooRun_GetFooProgress_Call) Return(getFooProgressResponse *examplev1.GetFooProgressResponse, err error) *MockCreateFooRun_GetFooProgress_Call {
	_c.Call.Return(getFooProgressResponse, err)
	return _c
}

func (_c *MockCreateFooRun_GetFooProgress_Call) RunAndReturn(run func(ctx context.Context) (*examplev1.GetFooProgressResponse, error)) *MockCreateFooRun_GetFooProgress_Call {
	_c.Call.Return(run)
	return _c
}

// ID provides a mock function for the type MockCreateFooRun
func (_mock *MockCreateFooRun) ID() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// ID is a helper method to define mock.On call
func (_e *MockCreateFooRun_Expecter) ID() *MockCreateFooRun_ID_Call {
	return &MockCreateFooRun_ID_Call{Call: _e.mock.On("ID")}
}

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

func (_c *MockCreateFooRun_ID_Call) Return(s string) *MockCreateFooRun_ID_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockCreateFooRun_ID_Call) RunAndReturn(run func() string) *MockCreateFooRun_ID_Call {
	_c.Call.Return(run)
	return _c
}

// Run provides a mock function for the type MockCreateFooRun
func (_mock *MockCreateFooRun) Run() client.WorkflowRun {
	ret := _mock.Called()

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

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

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

// Run is a helper method to define mock.On call
func (_e *MockCreateFooRun_Expecter) Run() *MockCreateFooRun_Run_Call {
	return &MockCreateFooRun_Run_Call{Call: _e.mock.On("Run")}
}

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

func (_c *MockCreateFooRun_Run_Call) Return(v client.WorkflowRun) *MockCreateFooRun_Run_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockCreateFooRun_Run_Call) RunAndReturn(run func() client.WorkflowRun) *MockCreateFooRun_Run_Call {
	_c.Call.Return(run)
	return _c
}

// RunID provides a mock function for the type MockCreateFooRun
func (_mock *MockCreateFooRun) RunID() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// RunID is a helper method to define mock.On call
func (_e *MockCreateFooRun_Expecter) RunID() *MockCreateFooRun_RunID_Call {
	return &MockCreateFooRun_RunID_Call{Call: _e.mock.On("RunID")}
}

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

func (_c *MockCreateFooRun_RunID_Call) Return(s string) *MockCreateFooRun_RunID_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockCreateFooRun_RunID_Call) RunAndReturn(run func() string) *MockCreateFooRun_RunID_Call {
	_c.Call.Return(run)
	return _c
}

// SetFooProgress provides a mock function for the type MockCreateFooRun
func (_mock *MockCreateFooRun) SetFooProgress(ctx context.Context, req *examplev1.SetFooProgressRequest) error {
	ret := _mock.Called(ctx, req)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *examplev1.SetFooProgressRequest) error); ok {
		r0 = returnFunc(ctx, req)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetFooProgress is a helper method to define mock.On call
//   - ctx context.Context
//   - req *examplev1.SetFooProgressRequest
func (_e *MockCreateFooRun_Expecter) SetFooProgress(ctx interface{}, req interface{}) *MockCreateFooRun_SetFooProgress_Call {
	return &MockCreateFooRun_SetFooProgress_Call{Call: _e.mock.On("SetFooProgress", ctx, req)}
}

func (_c *MockCreateFooRun_SetFooProgress_Call) Run(run func(ctx context.Context, req *examplev1.SetFooProgressRequest)) *MockCreateFooRun_SetFooProgress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *examplev1.SetFooProgressRequest
		if args[1] != nil {
			arg1 = args[1].(*examplev1.SetFooProgressRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockCreateFooRun_SetFooProgress_Call) Return(err error) *MockCreateFooRun_SetFooProgress_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockCreateFooRun_SetFooProgress_Call) RunAndReturn(run func(ctx context.Context, req *examplev1.SetFooProgressRequest) error) *MockCreateFooRun_SetFooProgress_Call {
	_c.Call.Return(run)
	return _c
}

// Terminate provides a mock function for the type MockCreateFooRun
func (_mock *MockCreateFooRun) Terminate(ctx context.Context, reason string, details ...interface{}) error {
	var _ca []interface{}
	_ca = append(_ca, ctx, reason)
	_ca = append(_ca, details...)
	ret := _mock.Called(_ca...)

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

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

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

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

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

func (_c *MockCreateFooRun_Terminate_Call) Return(err error) *MockCreateFooRun_Terminate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockCreateFooRun_Terminate_Call) RunAndReturn(run func(ctx context.Context, reason string, details ...interface{}) error) *MockCreateFooRun_Terminate_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateFooProgress provides a mock function for the type MockCreateFooRun
func (_mock *MockCreateFooRun) UpdateFooProgress(ctx context.Context, req *examplev1.SetFooProgressRequest, opts ...*examplev1.UpdateFooProgressOptions) (*examplev1.GetFooProgressResponse, error) {
	// *examplev1.UpdateFooProgressOptions
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, req)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *examplev1.GetFooProgressResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *examplev1.SetFooProgressRequest, ...*examplev1.UpdateFooProgressOptions) (*examplev1.GetFooProgressResponse, error)); ok {
		return returnFunc(ctx, req, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *examplev1.SetFooProgressRequest, ...*examplev1.UpdateFooProgressOptions) *examplev1.GetFooProgressResponse); ok {
		r0 = returnFunc(ctx, req, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*examplev1.GetFooProgressResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *examplev1.SetFooProgressRequest, ...*examplev1.UpdateFooProgressOptions) error); ok {
		r1 = returnFunc(ctx, req, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateFooProgress is a helper method to define mock.On call
//   - ctx context.Context
//   - req *examplev1.SetFooProgressRequest
//   - opts ...*examplev1.UpdateFooProgressOptions
func (_e *MockCreateFooRun_Expecter) UpdateFooProgress(ctx interface{}, req interface{}, opts ...interface{}) *MockCreateFooRun_UpdateFooProgress_Call {
	return &MockCreateFooRun_UpdateFooProgress_Call{Call: _e.mock.On("UpdateFooProgress",
		append([]interface{}{ctx, req}, opts...)...)}
}

func (_c *MockCreateFooRun_UpdateFooProgress_Call) Run(run func(ctx context.Context, req *examplev1.SetFooProgressRequest, opts ...*examplev1.UpdateFooProgressOptions)) *MockCreateFooRun_UpdateFooProgress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *examplev1.SetFooProgressRequest
		if args[1] != nil {
			arg1 = args[1].(*examplev1.SetFooProgressRequest)
		}
		var arg2 []*examplev1.UpdateFooProgressOptions
		variadicArgs := make([]*examplev1.UpdateFooProgressOptions, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(*examplev1.UpdateFooProgressOptions)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *MockCreateFooRun_UpdateFooProgress_Call) Return(getFooProgressResponse *examplev1.GetFooProgressResponse, err error) *MockCreateFooRun_UpdateFooProgress_Call {
	_c.Call.Return(getFooProgressResponse, err)
	return _c
}

func (_c *MockCreateFooRun_UpdateFooProgress_Call) RunAndReturn(run func(ctx context.Context, req *examplev1.SetFooProgressRequest, opts ...*examplev1.UpdateFooProgressOptions) (*examplev1.GetFooProgressResponse, error)) *MockCreateFooRun_UpdateFooProgress_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateFooProgressAsync provides a mock function for the type MockCreateFooRun
func (_mock *MockCreateFooRun) UpdateFooProgressAsync(ctx context.Context, req *examplev1.SetFooProgressRequest, opts ...*examplev1.UpdateFooProgressOptions) (examplev1.UpdateFooProgressHandle, error) {
	// *examplev1.UpdateFooProgressOptions
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, req)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 examplev1.UpdateFooProgressHandle
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *examplev1.SetFooProgressRequest, ...*examplev1.UpdateFooProgressOptions) (examplev1.UpdateFooProgressHandle, error)); ok {
		return returnFunc(ctx, req, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *examplev1.SetFooProgressRequest, ...*examplev1.UpdateFooProgressOptions) examplev1.UpdateFooProgressHandle); ok {
		r0 = returnFunc(ctx, req, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(examplev1.UpdateFooProgressHandle)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *examplev1.SetFooProgressRequest, ...*examplev1.UpdateFooProgressOptions) error); ok {
		r1 = returnFunc(ctx, req, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateFooProgressAsync is a helper method to define mock.On call
//   - ctx context.Context
//   - req *examplev1.SetFooProgressRequest
//   - opts ...*examplev1.UpdateFooProgressOptions
func (_e *MockCreateFooRun_Expecter) UpdateFooProgressAsync(ctx interface{}, req interface{}, opts ...interface{}) *MockCreateFooRun_UpdateFooProgressAsync_Call {
	return &MockCreateFooRun_UpdateFooProgressAsync_Call{Call: _e.mock.On("UpdateFooProgressAsync",
		append([]interface{}{ctx, req}, opts...)...)}
}

func (_c *MockCreateFooRun_UpdateFooProgressAsync_Call) Run(run func(ctx context.Context, req *examplev1.SetFooProgressRequest, opts ...*examplev1.UpdateFooProgressOptions)) *MockCreateFooRun_UpdateFooProgressAsync_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *examplev1.SetFooProgressRequest
		if args[1] != nil {
			arg1 = args[1].(*examplev1.SetFooProgressRequest)
		}
		var arg2 []*examplev1.UpdateFooProgressOptions
		variadicArgs := make([]*examplev1.UpdateFooProgressOptions, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(*examplev1.UpdateFooProgressOptions)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *MockCreateFooRun_UpdateFooProgressAsync_Call) Return(updateFooProgressHandle examplev1.UpdateFooProgressHandle, err error) *MockCreateFooRun_UpdateFooProgressAsync_Call {
	_c.Call.Return(updateFooProgressHandle, err)
	return _c
}

func (_c *MockCreateFooRun_UpdateFooProgressAsync_Call) RunAndReturn(run func(ctx context.Context, req *examplev1.SetFooProgressRequest, opts ...*examplev1.UpdateFooProgressOptions) (examplev1.UpdateFooProgressHandle, error)) *MockCreateFooRun_UpdateFooProgressAsync_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockUpdateFooProgressHandle creates a new instance of MockUpdateFooProgressHandle. 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 NewMockUpdateFooProgressHandle(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockUpdateFooProgressHandle {
	mock := &MockUpdateFooProgressHandle{}
	mock.Mock.Test(t)

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

	return mock
}

// MockUpdateFooProgressHandle is an autogenerated mock type for the UpdateFooProgressHandle type
type MockUpdateFooProgressHandle struct {
	mock.Mock
}

type MockUpdateFooProgressHandle_Expecter struct {
	mock *mock.Mock
}

func (_m *MockUpdateFooProgressHandle) EXPECT() *MockUpdateFooProgressHandle_Expecter {
	return &MockUpdateFooProgressHandle_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockUpdateFooProgressHandle
func (_mock *MockUpdateFooProgressHandle) Get(ctx context.Context) (*examplev1.GetFooProgressResponse, error) {
	ret := _mock.Called(ctx)

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

	var r0 *examplev1.GetFooProgressResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (*examplev1.GetFooProgressResponse, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) *examplev1.GetFooProgressResponse); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*examplev1.GetFooProgressResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

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

func (_c *MockUpdateFooProgressHandle_Get_Call) Run(run func(ctx context.Context)) *MockUpdateFooProgressHandle_Get_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUpdateFooProgressHandle_Get_Call) Return(getFooProgressResponse *examplev1.GetFooProgressResponse, err error) *MockUpdateFooProgressHandle_Get_Call {
	_c.Call.Return(getFooProgressResponse, err)
	return _c
}

func (_c *MockUpdateFooProgressHandle_Get_Call) RunAndReturn(run func(ctx context.Context) (*examplev1.GetFooProgressResponse, error)) *MockUpdateFooProgressHandle_Get_Call {
	_c.Call.Return(run)
	return _c
}

// RunID provides a mock function for the type MockUpdateFooProgressHandle
func (_mock *MockUpdateFooProgressHandle) RunID() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// RunID is a helper method to define mock.On call
func (_e *MockUpdateFooProgressHandle_Expecter) RunID() *MockUpdateFooProgressHandle_RunID_Call {
	return &MockUpdateFooProgressHandle_RunID_Call{Call: _e.mock.On("RunID")}
}

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

func (_c *MockUpdateFooProgressHandle_RunID_Call) Return(s string) *MockUpdateFooProgressHandle_RunID_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockUpdateFooProgressHandle_RunID_Call) RunAndReturn(run func() string) *MockUpdateFooProgressHandle_RunID_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateID provides a mock function for the type MockUpdateFooProgressHandle
func (_mock *MockUpdateFooProgressHandle) UpdateID() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// UpdateID is a helper method to define mock.On call
func (_e *MockUpdateFooProgressHandle_Expecter) UpdateID() *MockUpdateFooProgressHandle_UpdateID_Call {
	return &MockUpdateFooProgressHandle_UpdateID_Call{Call: _e.mock.On("UpdateID")}
}

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

func (_c *MockUpdateFooProgressHandle_UpdateID_Call) Return(s string) *MockUpdateFooProgressHandle_UpdateID_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockUpdateFooProgressHandle_UpdateID_Call) RunAndReturn(run func() string) *MockUpdateFooProgressHandle_UpdateID_Call {
	_c.Call.Return(run)
	return _c
}

// WorkflowID provides a mock function for the type MockUpdateFooProgressHandle
func (_mock *MockUpdateFooProgressHandle) WorkflowID() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// WorkflowID is a helper method to define mock.On call
func (_e *MockUpdateFooProgressHandle_Expecter) WorkflowID() *MockUpdateFooProgressHandle_WorkflowID_Call {
	return &MockUpdateFooProgressHandle_WorkflowID_Call{Call: _e.mock.On("WorkflowID")}
}

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

func (_c *MockUpdateFooProgressHandle_WorkflowID_Call) Return(s string) *MockUpdateFooProgressHandle_WorkflowID_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockUpdateFooProgressHandle_WorkflowID_Call) RunAndReturn(run func() string) *MockUpdateFooProgressHandle_WorkflowID_Call {
	_c.Call.Return(run)
	return _c
}
