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

package mocks

import (
	"context"
	"time"

	"code.forgejo.org/forgejo/actions-proto/ping/v1"
	"code.forgejo.org/forgejo/actions-proto/runner/v1"
	"connectrpc.com/connect"

	"github.com/google/uuid"
	mock "github.com/stretchr/testify/mock"
)

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

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

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

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

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

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

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

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

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

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

// Declare provides a mock function for the type MockClient
func (_mock *MockClient) Declare(context1 context.Context, request *connect.Request[runnerv1.DeclareRequest]) (*connect.Response[runnerv1.DeclareResponse], error) {
	ret := _mock.Called(context1, request)

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

	var r0 *connect.Response[runnerv1.DeclareResponse]
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[runnerv1.DeclareRequest]) (*connect.Response[runnerv1.DeclareResponse], error)); ok {
		return returnFunc(context1, request)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[runnerv1.DeclareRequest]) *connect.Response[runnerv1.DeclareResponse]); ok {
		r0 = returnFunc(context1, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[runnerv1.DeclareResponse])
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[runnerv1.DeclareRequest]) error); ok {
		r1 = returnFunc(context1, request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Declare is a helper method to define mock.On call
//   - context1 context.Context
//   - request *connect.Request[runnerv1.DeclareRequest]
func (_e *MockClient_Expecter) Declare(context1 any, request any) *MockClient_Declare_Call {
	return &MockClient_Declare_Call{Call: _e.mock.On("Declare", context1, request)}
}

func (_c *MockClient_Declare_Call) Run(run func(context1 context.Context, request *connect.Request[runnerv1.DeclareRequest])) *MockClient_Declare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *connect.Request[runnerv1.DeclareRequest]
		if args[1] != nil {
			arg1 = args[1].(*connect.Request[runnerv1.DeclareRequest])
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_Declare_Call) Return(response *connect.Response[runnerv1.DeclareResponse], err error) *MockClient_Declare_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockClient_Declare_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[runnerv1.DeclareRequest]) (*connect.Response[runnerv1.DeclareResponse], error)) *MockClient_Declare_Call {
	_c.Call.Return(run)
	return _c
}

// FetchInterval provides a mock function for the type MockClient
func (_mock *MockClient) FetchInterval() time.Duration {
	ret := _mock.Called()

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

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

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

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

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

func (_c *MockClient_FetchInterval_Call) Return(duration time.Duration) *MockClient_FetchInterval_Call {
	_c.Call.Return(duration)
	return _c
}

func (_c *MockClient_FetchInterval_Call) RunAndReturn(run func() time.Duration) *MockClient_FetchInterval_Call {
	_c.Call.Return(run)
	return _c
}

// FetchSingleTask provides a mock function for the type MockClient
func (_mock *MockClient) FetchSingleTask(context1 context.Context, request *connect.Request[runnerv1.FetchSingleTaskRequest]) (*connect.Response[runnerv1.FetchSingleTaskResponse], error) {
	ret := _mock.Called(context1, request)

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

	var r0 *connect.Response[runnerv1.FetchSingleTaskResponse]
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[runnerv1.FetchSingleTaskRequest]) (*connect.Response[runnerv1.FetchSingleTaskResponse], error)); ok {
		return returnFunc(context1, request)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[runnerv1.FetchSingleTaskRequest]) *connect.Response[runnerv1.FetchSingleTaskResponse]); ok {
		r0 = returnFunc(context1, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[runnerv1.FetchSingleTaskResponse])
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[runnerv1.FetchSingleTaskRequest]) error); ok {
		r1 = returnFunc(context1, request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// FetchSingleTask is a helper method to define mock.On call
//   - context1 context.Context
//   - request *connect.Request[runnerv1.FetchSingleTaskRequest]
func (_e *MockClient_Expecter) FetchSingleTask(context1 any, request any) *MockClient_FetchSingleTask_Call {
	return &MockClient_FetchSingleTask_Call{Call: _e.mock.On("FetchSingleTask", context1, request)}
}

func (_c *MockClient_FetchSingleTask_Call) Run(run func(context1 context.Context, request *connect.Request[runnerv1.FetchSingleTaskRequest])) *MockClient_FetchSingleTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *connect.Request[runnerv1.FetchSingleTaskRequest]
		if args[1] != nil {
			arg1 = args[1].(*connect.Request[runnerv1.FetchSingleTaskRequest])
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_FetchSingleTask_Call) Return(response *connect.Response[runnerv1.FetchSingleTaskResponse], err error) *MockClient_FetchSingleTask_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockClient_FetchSingleTask_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[runnerv1.FetchSingleTaskRequest]) (*connect.Response[runnerv1.FetchSingleTaskResponse], error)) *MockClient_FetchSingleTask_Call {
	_c.Call.Return(run)
	return _c
}

// FetchTask provides a mock function for the type MockClient
func (_mock *MockClient) FetchTask(context1 context.Context, request *connect.Request[runnerv1.FetchTaskRequest]) (*connect.Response[runnerv1.FetchTaskResponse], error) {
	ret := _mock.Called(context1, request)

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

	var r0 *connect.Response[runnerv1.FetchTaskResponse]
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[runnerv1.FetchTaskRequest]) (*connect.Response[runnerv1.FetchTaskResponse], error)); ok {
		return returnFunc(context1, request)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[runnerv1.FetchTaskRequest]) *connect.Response[runnerv1.FetchTaskResponse]); ok {
		r0 = returnFunc(context1, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[runnerv1.FetchTaskResponse])
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[runnerv1.FetchTaskRequest]) error); ok {
		r1 = returnFunc(context1, request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// FetchTask is a helper method to define mock.On call
//   - context1 context.Context
//   - request *connect.Request[runnerv1.FetchTaskRequest]
func (_e *MockClient_Expecter) FetchTask(context1 any, request any) *MockClient_FetchTask_Call {
	return &MockClient_FetchTask_Call{Call: _e.mock.On("FetchTask", context1, request)}
}

func (_c *MockClient_FetchTask_Call) Run(run func(context1 context.Context, request *connect.Request[runnerv1.FetchTaskRequest])) *MockClient_FetchTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *connect.Request[runnerv1.FetchTaskRequest]
		if args[1] != nil {
			arg1 = args[1].(*connect.Request[runnerv1.FetchTaskRequest])
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_FetchTask_Call) Return(response *connect.Response[runnerv1.FetchTaskResponse], err error) *MockClient_FetchTask_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockClient_FetchTask_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[runnerv1.FetchTaskRequest]) (*connect.Response[runnerv1.FetchTaskResponse], error)) *MockClient_FetchTask_Call {
	_c.Call.Return(run)
	return _c
}

// Insecure provides a mock function for the type MockClient
func (_mock *MockClient) Insecure() bool {
	ret := _mock.Called()

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

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

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

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

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

func (_c *MockClient_Insecure_Call) Return(b bool) *MockClient_Insecure_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockClient_Insecure_Call) RunAndReturn(run func() bool) *MockClient_Insecure_Call {
	_c.Call.Return(run)
	return _c
}

// Ping provides a mock function for the type MockClient
func (_mock *MockClient) Ping(context1 context.Context, request *connect.Request[pingv1.PingRequest]) (*connect.Response[pingv1.PingResponse], error) {
	ret := _mock.Called(context1, request)

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

	var r0 *connect.Response[pingv1.PingResponse]
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[pingv1.PingRequest]) (*connect.Response[pingv1.PingResponse], error)); ok {
		return returnFunc(context1, request)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[pingv1.PingRequest]) *connect.Response[pingv1.PingResponse]); ok {
		r0 = returnFunc(context1, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[pingv1.PingResponse])
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[pingv1.PingRequest]) error); ok {
		r1 = returnFunc(context1, request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Ping is a helper method to define mock.On call
//   - context1 context.Context
//   - request *connect.Request[pingv1.PingRequest]
func (_e *MockClient_Expecter) Ping(context1 any, request any) *MockClient_Ping_Call {
	return &MockClient_Ping_Call{Call: _e.mock.On("Ping", context1, request)}
}

func (_c *MockClient_Ping_Call) Run(run func(context1 context.Context, request *connect.Request[pingv1.PingRequest])) *MockClient_Ping_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *connect.Request[pingv1.PingRequest]
		if args[1] != nil {
			arg1 = args[1].(*connect.Request[pingv1.PingRequest])
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_Ping_Call) Return(response *connect.Response[pingv1.PingResponse], err error) *MockClient_Ping_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockClient_Ping_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[pingv1.PingRequest]) (*connect.Response[pingv1.PingResponse], error)) *MockClient_Ping_Call {
	_c.Call.Return(run)
	return _c
}

// Register provides a mock function for the type MockClient
func (_mock *MockClient) Register(context1 context.Context, request *connect.Request[runnerv1.RegisterRequest]) (*connect.Response[runnerv1.RegisterResponse], error) {
	ret := _mock.Called(context1, request)

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

	var r0 *connect.Response[runnerv1.RegisterResponse]
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[runnerv1.RegisterRequest]) (*connect.Response[runnerv1.RegisterResponse], error)); ok {
		return returnFunc(context1, request)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[runnerv1.RegisterRequest]) *connect.Response[runnerv1.RegisterResponse]); ok {
		r0 = returnFunc(context1, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[runnerv1.RegisterResponse])
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[runnerv1.RegisterRequest]) error); ok {
		r1 = returnFunc(context1, request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Register is a helper method to define mock.On call
//   - context1 context.Context
//   - request *connect.Request[runnerv1.RegisterRequest]
func (_e *MockClient_Expecter) Register(context1 any, request any) *MockClient_Register_Call {
	return &MockClient_Register_Call{Call: _e.mock.On("Register", context1, request)}
}

func (_c *MockClient_Register_Call) Run(run func(context1 context.Context, request *connect.Request[runnerv1.RegisterRequest])) *MockClient_Register_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *connect.Request[runnerv1.RegisterRequest]
		if args[1] != nil {
			arg1 = args[1].(*connect.Request[runnerv1.RegisterRequest])
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_Register_Call) Return(response *connect.Response[runnerv1.RegisterResponse], err error) *MockClient_Register_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockClient_Register_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[runnerv1.RegisterRequest]) (*connect.Response[runnerv1.RegisterResponse], error)) *MockClient_Register_Call {
	_c.Call.Return(run)
	return _c
}

// SetRequestKey provides a mock function for the type MockClient
func (_mock *MockClient) SetRequestKey(uUID uuid.UUID) func() {
	ret := _mock.Called(uUID)

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

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

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

// SetRequestKey is a helper method to define mock.On call
//   - uUID uuid.UUID
func (_e *MockClient_Expecter) SetRequestKey(uUID any) *MockClient_SetRequestKey_Call {
	return &MockClient_SetRequestKey_Call{Call: _e.mock.On("SetRequestKey", uUID)}
}

func (_c *MockClient_SetRequestKey_Call) Run(run func(uUID uuid.UUID)) *MockClient_SetRequestKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 uuid.UUID
		if args[0] != nil {
			arg0 = args[0].(uuid.UUID)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockClient_SetRequestKey_Call) Return(fn func()) *MockClient_SetRequestKey_Call {
	_c.Call.Return(fn)
	return _c
}

func (_c *MockClient_SetRequestKey_Call) RunAndReturn(run func(uUID uuid.UUID) func()) *MockClient_SetRequestKey_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateLog provides a mock function for the type MockClient
func (_mock *MockClient) UpdateLog(context1 context.Context, request *connect.Request[runnerv1.UpdateLogRequest]) (*connect.Response[runnerv1.UpdateLogResponse], error) {
	ret := _mock.Called(context1, request)

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

	var r0 *connect.Response[runnerv1.UpdateLogResponse]
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[runnerv1.UpdateLogRequest]) (*connect.Response[runnerv1.UpdateLogResponse], error)); ok {
		return returnFunc(context1, request)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[runnerv1.UpdateLogRequest]) *connect.Response[runnerv1.UpdateLogResponse]); ok {
		r0 = returnFunc(context1, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[runnerv1.UpdateLogResponse])
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[runnerv1.UpdateLogRequest]) error); ok {
		r1 = returnFunc(context1, request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateLog is a helper method to define mock.On call
//   - context1 context.Context
//   - request *connect.Request[runnerv1.UpdateLogRequest]
func (_e *MockClient_Expecter) UpdateLog(context1 any, request any) *MockClient_UpdateLog_Call {
	return &MockClient_UpdateLog_Call{Call: _e.mock.On("UpdateLog", context1, request)}
}

func (_c *MockClient_UpdateLog_Call) Run(run func(context1 context.Context, request *connect.Request[runnerv1.UpdateLogRequest])) *MockClient_UpdateLog_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *connect.Request[runnerv1.UpdateLogRequest]
		if args[1] != nil {
			arg1 = args[1].(*connect.Request[runnerv1.UpdateLogRequest])
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_UpdateLog_Call) Return(response *connect.Response[runnerv1.UpdateLogResponse], err error) *MockClient_UpdateLog_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockClient_UpdateLog_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[runnerv1.UpdateLogRequest]) (*connect.Response[runnerv1.UpdateLogResponse], error)) *MockClient_UpdateLog_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateStepSummary provides a mock function for the type MockClient
func (_mock *MockClient) UpdateStepSummary(context1 context.Context, request *connect.Request[runnerv1.UpdateStepSummaryRequest]) (*connect.Response[runnerv1.UpdateStepSummaryResponse], error) {
	ret := _mock.Called(context1, request)

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

	var r0 *connect.Response[runnerv1.UpdateStepSummaryResponse]
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[runnerv1.UpdateStepSummaryRequest]) (*connect.Response[runnerv1.UpdateStepSummaryResponse], error)); ok {
		return returnFunc(context1, request)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[runnerv1.UpdateStepSummaryRequest]) *connect.Response[runnerv1.UpdateStepSummaryResponse]); ok {
		r0 = returnFunc(context1, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[runnerv1.UpdateStepSummaryResponse])
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[runnerv1.UpdateStepSummaryRequest]) error); ok {
		r1 = returnFunc(context1, request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateStepSummary is a helper method to define mock.On call
//   - context1 context.Context
//   - request *connect.Request[runnerv1.UpdateStepSummaryRequest]
func (_e *MockClient_Expecter) UpdateStepSummary(context1 any, request any) *MockClient_UpdateStepSummary_Call {
	return &MockClient_UpdateStepSummary_Call{Call: _e.mock.On("UpdateStepSummary", context1, request)}
}

func (_c *MockClient_UpdateStepSummary_Call) Run(run func(context1 context.Context, request *connect.Request[runnerv1.UpdateStepSummaryRequest])) *MockClient_UpdateStepSummary_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *connect.Request[runnerv1.UpdateStepSummaryRequest]
		if args[1] != nil {
			arg1 = args[1].(*connect.Request[runnerv1.UpdateStepSummaryRequest])
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_UpdateStepSummary_Call) Return(response *connect.Response[runnerv1.UpdateStepSummaryResponse], err error) *MockClient_UpdateStepSummary_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockClient_UpdateStepSummary_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[runnerv1.UpdateStepSummaryRequest]) (*connect.Response[runnerv1.UpdateStepSummaryResponse], error)) *MockClient_UpdateStepSummary_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTask provides a mock function for the type MockClient
func (_mock *MockClient) UpdateTask(context1 context.Context, request *connect.Request[runnerv1.UpdateTaskRequest]) (*connect.Response[runnerv1.UpdateTaskResponse], error) {
	ret := _mock.Called(context1, request)

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

	var r0 *connect.Response[runnerv1.UpdateTaskResponse]
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[runnerv1.UpdateTaskRequest]) (*connect.Response[runnerv1.UpdateTaskResponse], error)); ok {
		return returnFunc(context1, request)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[runnerv1.UpdateTaskRequest]) *connect.Response[runnerv1.UpdateTaskResponse]); ok {
		r0 = returnFunc(context1, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[runnerv1.UpdateTaskResponse])
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[runnerv1.UpdateTaskRequest]) error); ok {
		r1 = returnFunc(context1, request)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateTask is a helper method to define mock.On call
//   - context1 context.Context
//   - request *connect.Request[runnerv1.UpdateTaskRequest]
func (_e *MockClient_Expecter) UpdateTask(context1 any, request any) *MockClient_UpdateTask_Call {
	return &MockClient_UpdateTask_Call{Call: _e.mock.On("UpdateTask", context1, request)}
}

func (_c *MockClient_UpdateTask_Call) Run(run func(context1 context.Context, request *connect.Request[runnerv1.UpdateTaskRequest])) *MockClient_UpdateTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *connect.Request[runnerv1.UpdateTaskRequest]
		if args[1] != nil {
			arg1 = args[1].(*connect.Request[runnerv1.UpdateTaskRequest])
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockClient_UpdateTask_Call) Return(response *connect.Response[runnerv1.UpdateTaskResponse], err error) *MockClient_UpdateTask_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockClient_UpdateTask_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[runnerv1.UpdateTaskRequest]) (*connect.Response[runnerv1.UpdateTaskResponse], error)) *MockClient_UpdateTask_Call {
	_c.Call.Return(run)
	return _c
}
