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

package mocks

import (
	"context"

	"github.com/apache/airflow/go-sdk/pkg/api"
	"github.com/oapi-codegen/runtime/types"
	mock "github.com/stretchr/testify/mock"
	"resty.dev/v3"
)

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

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

	return mock
}

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

type TaskInstancesClient_Expecter struct {
	mock *mock.Mock
}

func (_m *TaskInstancesClient) EXPECT() *TaskInstancesClient_Expecter {
	return &TaskInstancesClient_Expecter{mock: &_m.Mock}
}

// GetCount provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) GetCount(ctx context.Context, params *api.GetTaskInstanceCountParams) (*int, error) {
	ret := _mock.Called(ctx, params)

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

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

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

// GetCount is a helper method to define mock.On call
//   - ctx context.Context
//   - params *api.GetTaskInstanceCountParams
func (_e *TaskInstancesClient_Expecter) GetCount(ctx interface{}, params interface{}) *TaskInstancesClient_GetCount_Call {
	return &TaskInstancesClient_GetCount_Call{Call: _e.mock.On("GetCount", ctx, params)}
}

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

func (_c *TaskInstancesClient_GetCount_Call) Return(n *int, err error) *TaskInstancesClient_GetCount_Call {
	_c.Call.Return(n, err)
	return _c
}

func (_c *TaskInstancesClient_GetCount_Call) RunAndReturn(run func(ctx context.Context, params *api.GetTaskInstanceCountParams) (*int, error)) *TaskInstancesClient_GetCount_Call {
	_c.Call.Return(run)
	return _c
}

// GetCountResponse provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) GetCountResponse(ctx context.Context, params *api.GetTaskInstanceCountParams) (*resty.Response, error) {
	ret := _mock.Called(ctx, params)

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

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

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

// GetCountResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - params *api.GetTaskInstanceCountParams
func (_e *TaskInstancesClient_Expecter) GetCountResponse(ctx interface{}, params interface{}) *TaskInstancesClient_GetCountResponse_Call {
	return &TaskInstancesClient_GetCountResponse_Call{Call: _e.mock.On("GetCountResponse", ctx, params)}
}

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

func (_c *TaskInstancesClient_GetCountResponse_Call) Return(response *resty.Response, err error) *TaskInstancesClient_GetCountResponse_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *TaskInstancesClient_GetCountResponse_Call) RunAndReturn(run func(ctx context.Context, params *api.GetTaskInstanceCountParams) (*resty.Response, error)) *TaskInstancesClient_GetCountResponse_Call {
	_c.Call.Return(run)
	return _c
}

// GetPreviousSuccessfulDagrun provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) GetPreviousSuccessfulDagrun(ctx context.Context, taskInstanceId types.UUID) (*api.PrevSuccessfulDagRunResponse, error) {
	ret := _mock.Called(ctx, taskInstanceId)

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

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

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

// GetPreviousSuccessfulDagrun is a helper method to define mock.On call
//   - ctx context.Context
//   - taskInstanceId types.UUID
func (_e *TaskInstancesClient_Expecter) GetPreviousSuccessfulDagrun(ctx interface{}, taskInstanceId interface{}) *TaskInstancesClient_GetPreviousSuccessfulDagrun_Call {
	return &TaskInstancesClient_GetPreviousSuccessfulDagrun_Call{Call: _e.mock.On("GetPreviousSuccessfulDagrun", ctx, taskInstanceId)}
}

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

func (_c *TaskInstancesClient_GetPreviousSuccessfulDagrun_Call) Return(prevSuccessfulDagRunResponse *api.PrevSuccessfulDagRunResponse, err error) *TaskInstancesClient_GetPreviousSuccessfulDagrun_Call {
	_c.Call.Return(prevSuccessfulDagRunResponse, err)
	return _c
}

func (_c *TaskInstancesClient_GetPreviousSuccessfulDagrun_Call) RunAndReturn(run func(ctx context.Context, taskInstanceId types.UUID) (*api.PrevSuccessfulDagRunResponse, error)) *TaskInstancesClient_GetPreviousSuccessfulDagrun_Call {
	_c.Call.Return(run)
	return _c
}

// GetPreviousSuccessfulDagrunResponse provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) GetPreviousSuccessfulDagrunResponse(ctx context.Context, taskInstanceId types.UUID) (*resty.Response, error) {
	ret := _mock.Called(ctx, taskInstanceId)

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

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

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

// GetPreviousSuccessfulDagrunResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - taskInstanceId types.UUID
func (_e *TaskInstancesClient_Expecter) GetPreviousSuccessfulDagrunResponse(ctx interface{}, taskInstanceId interface{}) *TaskInstancesClient_GetPreviousSuccessfulDagrunResponse_Call {
	return &TaskInstancesClient_GetPreviousSuccessfulDagrunResponse_Call{Call: _e.mock.On("GetPreviousSuccessfulDagrunResponse", ctx, taskInstanceId)}
}

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

func (_c *TaskInstancesClient_GetPreviousSuccessfulDagrunResponse_Call) Return(response *resty.Response, err error) *TaskInstancesClient_GetPreviousSuccessfulDagrunResponse_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *TaskInstancesClient_GetPreviousSuccessfulDagrunResponse_Call) RunAndReturn(run func(ctx context.Context, taskInstanceId types.UUID) (*resty.Response, error)) *TaskInstancesClient_GetPreviousSuccessfulDagrunResponse_Call {
	_c.Call.Return(run)
	return _c
}

// GetStates provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) GetStates(ctx context.Context, params *api.GetTaskInstanceStatesParams) (*api.TaskStatesResponse, error) {
	ret := _mock.Called(ctx, params)

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

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

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

// GetStates is a helper method to define mock.On call
//   - ctx context.Context
//   - params *api.GetTaskInstanceStatesParams
func (_e *TaskInstancesClient_Expecter) GetStates(ctx interface{}, params interface{}) *TaskInstancesClient_GetStates_Call {
	return &TaskInstancesClient_GetStates_Call{Call: _e.mock.On("GetStates", ctx, params)}
}

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

func (_c *TaskInstancesClient_GetStates_Call) Return(taskStatesResponse *api.TaskStatesResponse, err error) *TaskInstancesClient_GetStates_Call {
	_c.Call.Return(taskStatesResponse, err)
	return _c
}

func (_c *TaskInstancesClient_GetStates_Call) RunAndReturn(run func(ctx context.Context, params *api.GetTaskInstanceStatesParams) (*api.TaskStatesResponse, error)) *TaskInstancesClient_GetStates_Call {
	_c.Call.Return(run)
	return _c
}

// GetStatesResponse provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) GetStatesResponse(ctx context.Context, params *api.GetTaskInstanceStatesParams) (*resty.Response, error) {
	ret := _mock.Called(ctx, params)

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

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

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

// GetStatesResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - params *api.GetTaskInstanceStatesParams
func (_e *TaskInstancesClient_Expecter) GetStatesResponse(ctx interface{}, params interface{}) *TaskInstancesClient_GetStatesResponse_Call {
	return &TaskInstancesClient_GetStatesResponse_Call{Call: _e.mock.On("GetStatesResponse", ctx, params)}
}

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

func (_c *TaskInstancesClient_GetStatesResponse_Call) Return(response *resty.Response, err error) *TaskInstancesClient_GetStatesResponse_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *TaskInstancesClient_GetStatesResponse_Call) RunAndReturn(run func(ctx context.Context, params *api.GetTaskInstanceStatesParams) (*resty.Response, error)) *TaskInstancesClient_GetStatesResponse_Call {
	_c.Call.Return(run)
	return _c
}

// Heartbeat provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) Heartbeat(ctx context.Context, taskInstanceId types.UUID, body *api.TIHeartbeatInfo) error {
	ret := _mock.Called(ctx, taskInstanceId, body)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *api.TIHeartbeatInfo) error); ok {
		r0 = returnFunc(ctx, taskInstanceId, body)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Heartbeat is a helper method to define mock.On call
//   - ctx context.Context
//   - taskInstanceId types.UUID
//   - body *api.TIHeartbeatInfo
func (_e *TaskInstancesClient_Expecter) Heartbeat(ctx interface{}, taskInstanceId interface{}, body interface{}) *TaskInstancesClient_Heartbeat_Call {
	return &TaskInstancesClient_Heartbeat_Call{Call: _e.mock.On("Heartbeat", ctx, taskInstanceId, body)}
}

func (_c *TaskInstancesClient_Heartbeat_Call) Run(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TIHeartbeatInfo)) *TaskInstancesClient_Heartbeat_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 types.UUID
		if args[1] != nil {
			arg1 = args[1].(types.UUID)
		}
		var arg2 *api.TIHeartbeatInfo
		if args[2] != nil {
			arg2 = args[2].(*api.TIHeartbeatInfo)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *TaskInstancesClient_Heartbeat_Call) RunAndReturn(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TIHeartbeatInfo) error) *TaskInstancesClient_Heartbeat_Call {
	_c.Call.Return(run)
	return _c
}

// HeartbeatResponse provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) HeartbeatResponse(ctx context.Context, taskInstanceId types.UUID, body *api.TIHeartbeatInfo) (*resty.Response, error) {
	ret := _mock.Called(ctx, taskInstanceId, body)

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

	var r0 *resty.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *api.TIHeartbeatInfo) (*resty.Response, error)); ok {
		return returnFunc(ctx, taskInstanceId, body)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *api.TIHeartbeatInfo) *resty.Response); ok {
		r0 = returnFunc(ctx, taskInstanceId, body)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resty.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, types.UUID, *api.TIHeartbeatInfo) error); ok {
		r1 = returnFunc(ctx, taskInstanceId, body)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// HeartbeatResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - taskInstanceId types.UUID
//   - body *api.TIHeartbeatInfo
func (_e *TaskInstancesClient_Expecter) HeartbeatResponse(ctx interface{}, taskInstanceId interface{}, body interface{}) *TaskInstancesClient_HeartbeatResponse_Call {
	return &TaskInstancesClient_HeartbeatResponse_Call{Call: _e.mock.On("HeartbeatResponse", ctx, taskInstanceId, body)}
}

func (_c *TaskInstancesClient_HeartbeatResponse_Call) Run(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TIHeartbeatInfo)) *TaskInstancesClient_HeartbeatResponse_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 types.UUID
		if args[1] != nil {
			arg1 = args[1].(types.UUID)
		}
		var arg2 *api.TIHeartbeatInfo
		if args[2] != nil {
			arg2 = args[2].(*api.TIHeartbeatInfo)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *TaskInstancesClient_HeartbeatResponse_Call) Return(response *resty.Response, err error) *TaskInstancesClient_HeartbeatResponse_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *TaskInstancesClient_HeartbeatResponse_Call) RunAndReturn(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TIHeartbeatInfo) (*resty.Response, error)) *TaskInstancesClient_HeartbeatResponse_Call {
	_c.Call.Return(run)
	return _c
}

// PutRenderedFields provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) PutRenderedFields(ctx context.Context, taskInstanceId types.UUID, body *map[string]*api.JsonValue) (*interface{}, error) {
	ret := _mock.Called(ctx, taskInstanceId, body)

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

	var r0 *interface{}
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *map[string]*api.JsonValue) (*interface{}, error)); ok {
		return returnFunc(ctx, taskInstanceId, body)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *map[string]*api.JsonValue) *interface{}); ok {
		r0 = returnFunc(ctx, taskInstanceId, body)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*interface{})
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, types.UUID, *map[string]*api.JsonValue) error); ok {
		r1 = returnFunc(ctx, taskInstanceId, body)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PutRenderedFields is a helper method to define mock.On call
//   - ctx context.Context
//   - taskInstanceId types.UUID
//   - body *map[string]*api.JsonValue
func (_e *TaskInstancesClient_Expecter) PutRenderedFields(ctx interface{}, taskInstanceId interface{}, body interface{}) *TaskInstancesClient_PutRenderedFields_Call {
	return &TaskInstancesClient_PutRenderedFields_Call{Call: _e.mock.On("PutRenderedFields", ctx, taskInstanceId, body)}
}

func (_c *TaskInstancesClient_PutRenderedFields_Call) Run(run func(ctx context.Context, taskInstanceId types.UUID, body *map[string]*api.JsonValue)) *TaskInstancesClient_PutRenderedFields_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 types.UUID
		if args[1] != nil {
			arg1 = args[1].(types.UUID)
		}
		var arg2 *map[string]*api.JsonValue
		if args[2] != nil {
			arg2 = args[2].(*map[string]*api.JsonValue)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *TaskInstancesClient_PutRenderedFields_Call) Return(ifaceVal *interface{}, err error) *TaskInstancesClient_PutRenderedFields_Call {
	_c.Call.Return(ifaceVal, err)
	return _c
}

func (_c *TaskInstancesClient_PutRenderedFields_Call) RunAndReturn(run func(ctx context.Context, taskInstanceId types.UUID, body *map[string]*api.JsonValue) (*interface{}, error)) *TaskInstancesClient_PutRenderedFields_Call {
	_c.Call.Return(run)
	return _c
}

// PutRenderedFieldsResponse provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) PutRenderedFieldsResponse(ctx context.Context, taskInstanceId types.UUID, body *map[string]*api.JsonValue) (*resty.Response, error) {
	ret := _mock.Called(ctx, taskInstanceId, body)

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

	var r0 *resty.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *map[string]*api.JsonValue) (*resty.Response, error)); ok {
		return returnFunc(ctx, taskInstanceId, body)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *map[string]*api.JsonValue) *resty.Response); ok {
		r0 = returnFunc(ctx, taskInstanceId, body)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resty.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, types.UUID, *map[string]*api.JsonValue) error); ok {
		r1 = returnFunc(ctx, taskInstanceId, body)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PutRenderedFieldsResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - taskInstanceId types.UUID
//   - body *map[string]*api.JsonValue
func (_e *TaskInstancesClient_Expecter) PutRenderedFieldsResponse(ctx interface{}, taskInstanceId interface{}, body interface{}) *TaskInstancesClient_PutRenderedFieldsResponse_Call {
	return &TaskInstancesClient_PutRenderedFieldsResponse_Call{Call: _e.mock.On("PutRenderedFieldsResponse", ctx, taskInstanceId, body)}
}

func (_c *TaskInstancesClient_PutRenderedFieldsResponse_Call) Run(run func(ctx context.Context, taskInstanceId types.UUID, body *map[string]*api.JsonValue)) *TaskInstancesClient_PutRenderedFieldsResponse_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 types.UUID
		if args[1] != nil {
			arg1 = args[1].(types.UUID)
		}
		var arg2 *map[string]*api.JsonValue
		if args[2] != nil {
			arg2 = args[2].(*map[string]*api.JsonValue)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *TaskInstancesClient_PutRenderedFieldsResponse_Call) Return(response *resty.Response, err error) *TaskInstancesClient_PutRenderedFieldsResponse_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *TaskInstancesClient_PutRenderedFieldsResponse_Call) RunAndReturn(run func(ctx context.Context, taskInstanceId types.UUID, body *map[string]*api.JsonValue) (*resty.Response, error)) *TaskInstancesClient_PutRenderedFieldsResponse_Call {
	_c.Call.Return(run)
	return _c
}

// Run provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) Run(ctx context.Context, taskInstanceId types.UUID, body *api.TIEnterRunningPayload) (*api.TIRunContext, error) {
	ret := _mock.Called(ctx, taskInstanceId, body)

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

	var r0 *api.TIRunContext
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *api.TIEnterRunningPayload) (*api.TIRunContext, error)); ok {
		return returnFunc(ctx, taskInstanceId, body)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *api.TIEnterRunningPayload) *api.TIRunContext); ok {
		r0 = returnFunc(ctx, taskInstanceId, body)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*api.TIRunContext)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, types.UUID, *api.TIEnterRunningPayload) error); ok {
		r1 = returnFunc(ctx, taskInstanceId, body)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Run is a helper method to define mock.On call
//   - ctx context.Context
//   - taskInstanceId types.UUID
//   - body *api.TIEnterRunningPayload
func (_e *TaskInstancesClient_Expecter) Run(ctx interface{}, taskInstanceId interface{}, body interface{}) *TaskInstancesClient_Run_Call {
	return &TaskInstancesClient_Run_Call{Call: _e.mock.On("Run", ctx, taskInstanceId, body)}
}

func (_c *TaskInstancesClient_Run_Call) Run(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TIEnterRunningPayload)) *TaskInstancesClient_Run_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 types.UUID
		if args[1] != nil {
			arg1 = args[1].(types.UUID)
		}
		var arg2 *api.TIEnterRunningPayload
		if args[2] != nil {
			arg2 = args[2].(*api.TIEnterRunningPayload)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *TaskInstancesClient_Run_Call) Return(tIRunContext *api.TIRunContext, err error) *TaskInstancesClient_Run_Call {
	_c.Call.Return(tIRunContext, err)
	return _c
}

func (_c *TaskInstancesClient_Run_Call) RunAndReturn(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TIEnterRunningPayload) (*api.TIRunContext, error)) *TaskInstancesClient_Run_Call {
	_c.Call.Return(run)
	return _c
}

// RunResponse provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) RunResponse(ctx context.Context, taskInstanceId types.UUID, body *api.TIEnterRunningPayload) (*resty.Response, error) {
	ret := _mock.Called(ctx, taskInstanceId, body)

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

	var r0 *resty.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *api.TIEnterRunningPayload) (*resty.Response, error)); ok {
		return returnFunc(ctx, taskInstanceId, body)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *api.TIEnterRunningPayload) *resty.Response); ok {
		r0 = returnFunc(ctx, taskInstanceId, body)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resty.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, types.UUID, *api.TIEnterRunningPayload) error); ok {
		r1 = returnFunc(ctx, taskInstanceId, body)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// RunResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - taskInstanceId types.UUID
//   - body *api.TIEnterRunningPayload
func (_e *TaskInstancesClient_Expecter) RunResponse(ctx interface{}, taskInstanceId interface{}, body interface{}) *TaskInstancesClient_RunResponse_Call {
	return &TaskInstancesClient_RunResponse_Call{Call: _e.mock.On("RunResponse", ctx, taskInstanceId, body)}
}

func (_c *TaskInstancesClient_RunResponse_Call) Run(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TIEnterRunningPayload)) *TaskInstancesClient_RunResponse_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 types.UUID
		if args[1] != nil {
			arg1 = args[1].(types.UUID)
		}
		var arg2 *api.TIEnterRunningPayload
		if args[2] != nil {
			arg2 = args[2].(*api.TIEnterRunningPayload)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *TaskInstancesClient_RunResponse_Call) Return(response *resty.Response, err error) *TaskInstancesClient_RunResponse_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *TaskInstancesClient_RunResponse_Call) RunAndReturn(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TIEnterRunningPayload) (*resty.Response, error)) *TaskInstancesClient_RunResponse_Call {
	_c.Call.Return(run)
	return _c
}

// SkipDownstream provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) SkipDownstream(ctx context.Context, taskInstanceId types.UUID, body *api.TISkippedDownstreamTasksStatePayload) error {
	ret := _mock.Called(ctx, taskInstanceId, body)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *api.TISkippedDownstreamTasksStatePayload) error); ok {
		r0 = returnFunc(ctx, taskInstanceId, body)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SkipDownstream is a helper method to define mock.On call
//   - ctx context.Context
//   - taskInstanceId types.UUID
//   - body *api.TISkippedDownstreamTasksStatePayload
func (_e *TaskInstancesClient_Expecter) SkipDownstream(ctx interface{}, taskInstanceId interface{}, body interface{}) *TaskInstancesClient_SkipDownstream_Call {
	return &TaskInstancesClient_SkipDownstream_Call{Call: _e.mock.On("SkipDownstream", ctx, taskInstanceId, body)}
}

func (_c *TaskInstancesClient_SkipDownstream_Call) Run(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TISkippedDownstreamTasksStatePayload)) *TaskInstancesClient_SkipDownstream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 types.UUID
		if args[1] != nil {
			arg1 = args[1].(types.UUID)
		}
		var arg2 *api.TISkippedDownstreamTasksStatePayload
		if args[2] != nil {
			arg2 = args[2].(*api.TISkippedDownstreamTasksStatePayload)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *TaskInstancesClient_SkipDownstream_Call) RunAndReturn(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TISkippedDownstreamTasksStatePayload) error) *TaskInstancesClient_SkipDownstream_Call {
	_c.Call.Return(run)
	return _c
}

// SkipDownstreamResponse provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) SkipDownstreamResponse(ctx context.Context, taskInstanceId types.UUID, body *api.TISkippedDownstreamTasksStatePayload) (*resty.Response, error) {
	ret := _mock.Called(ctx, taskInstanceId, body)

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

	var r0 *resty.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *api.TISkippedDownstreamTasksStatePayload) (*resty.Response, error)); ok {
		return returnFunc(ctx, taskInstanceId, body)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *api.TISkippedDownstreamTasksStatePayload) *resty.Response); ok {
		r0 = returnFunc(ctx, taskInstanceId, body)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resty.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, types.UUID, *api.TISkippedDownstreamTasksStatePayload) error); ok {
		r1 = returnFunc(ctx, taskInstanceId, body)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SkipDownstreamResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - taskInstanceId types.UUID
//   - body *api.TISkippedDownstreamTasksStatePayload
func (_e *TaskInstancesClient_Expecter) SkipDownstreamResponse(ctx interface{}, taskInstanceId interface{}, body interface{}) *TaskInstancesClient_SkipDownstreamResponse_Call {
	return &TaskInstancesClient_SkipDownstreamResponse_Call{Call: _e.mock.On("SkipDownstreamResponse", ctx, taskInstanceId, body)}
}

func (_c *TaskInstancesClient_SkipDownstreamResponse_Call) Run(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TISkippedDownstreamTasksStatePayload)) *TaskInstancesClient_SkipDownstreamResponse_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 types.UUID
		if args[1] != nil {
			arg1 = args[1].(types.UUID)
		}
		var arg2 *api.TISkippedDownstreamTasksStatePayload
		if args[2] != nil {
			arg2 = args[2].(*api.TISkippedDownstreamTasksStatePayload)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *TaskInstancesClient_SkipDownstreamResponse_Call) Return(response *resty.Response, err error) *TaskInstancesClient_SkipDownstreamResponse_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *TaskInstancesClient_SkipDownstreamResponse_Call) RunAndReturn(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TISkippedDownstreamTasksStatePayload) (*resty.Response, error)) *TaskInstancesClient_SkipDownstreamResponse_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateState provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) UpdateState(ctx context.Context, taskInstanceId types.UUID, body *api.TIUpdateStatePayload) error {
	ret := _mock.Called(ctx, taskInstanceId, body)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *api.TIUpdateStatePayload) error); ok {
		r0 = returnFunc(ctx, taskInstanceId, body)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UpdateState is a helper method to define mock.On call
//   - ctx context.Context
//   - taskInstanceId types.UUID
//   - body *api.TIUpdateStatePayload
func (_e *TaskInstancesClient_Expecter) UpdateState(ctx interface{}, taskInstanceId interface{}, body interface{}) *TaskInstancesClient_UpdateState_Call {
	return &TaskInstancesClient_UpdateState_Call{Call: _e.mock.On("UpdateState", ctx, taskInstanceId, body)}
}

func (_c *TaskInstancesClient_UpdateState_Call) Run(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TIUpdateStatePayload)) *TaskInstancesClient_UpdateState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 types.UUID
		if args[1] != nil {
			arg1 = args[1].(types.UUID)
		}
		var arg2 *api.TIUpdateStatePayload
		if args[2] != nil {
			arg2 = args[2].(*api.TIUpdateStatePayload)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *TaskInstancesClient_UpdateState_Call) RunAndReturn(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TIUpdateStatePayload) error) *TaskInstancesClient_UpdateState_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateStateResponse provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) UpdateStateResponse(ctx context.Context, taskInstanceId types.UUID, body *api.TIUpdateStatePayload) (*resty.Response, error) {
	ret := _mock.Called(ctx, taskInstanceId, body)

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

	var r0 *resty.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *api.TIUpdateStatePayload) (*resty.Response, error)); ok {
		return returnFunc(ctx, taskInstanceId, body)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, types.UUID, *api.TIUpdateStatePayload) *resty.Response); ok {
		r0 = returnFunc(ctx, taskInstanceId, body)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resty.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, types.UUID, *api.TIUpdateStatePayload) error); ok {
		r1 = returnFunc(ctx, taskInstanceId, body)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateStateResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - taskInstanceId types.UUID
//   - body *api.TIUpdateStatePayload
func (_e *TaskInstancesClient_Expecter) UpdateStateResponse(ctx interface{}, taskInstanceId interface{}, body interface{}) *TaskInstancesClient_UpdateStateResponse_Call {
	return &TaskInstancesClient_UpdateStateResponse_Call{Call: _e.mock.On("UpdateStateResponse", ctx, taskInstanceId, body)}
}

func (_c *TaskInstancesClient_UpdateStateResponse_Call) Run(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TIUpdateStatePayload)) *TaskInstancesClient_UpdateStateResponse_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 types.UUID
		if args[1] != nil {
			arg1 = args[1].(types.UUID)
		}
		var arg2 *api.TIUpdateStatePayload
		if args[2] != nil {
			arg2 = args[2].(*api.TIUpdateStatePayload)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *TaskInstancesClient_UpdateStateResponse_Call) Return(response *resty.Response, err error) *TaskInstancesClient_UpdateStateResponse_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *TaskInstancesClient_UpdateStateResponse_Call) RunAndReturn(run func(ctx context.Context, taskInstanceId types.UUID, body *api.TIUpdateStatePayload) (*resty.Response, error)) *TaskInstancesClient_UpdateStateResponse_Call {
	_c.Call.Return(run)
	return _c
}

// ValidateInletsAndOutlets provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) ValidateInletsAndOutlets(ctx context.Context, taskInstanceId types.UUID) (*api.InactiveAssetsResponse, error) {
	ret := _mock.Called(ctx, taskInstanceId)

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

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

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

// ValidateInletsAndOutlets is a helper method to define mock.On call
//   - ctx context.Context
//   - taskInstanceId types.UUID
func (_e *TaskInstancesClient_Expecter) ValidateInletsAndOutlets(ctx interface{}, taskInstanceId interface{}) *TaskInstancesClient_ValidateInletsAndOutlets_Call {
	return &TaskInstancesClient_ValidateInletsAndOutlets_Call{Call: _e.mock.On("ValidateInletsAndOutlets", ctx, taskInstanceId)}
}

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

func (_c *TaskInstancesClient_ValidateInletsAndOutlets_Call) Return(inactiveAssetsResponse *api.InactiveAssetsResponse, err error) *TaskInstancesClient_ValidateInletsAndOutlets_Call {
	_c.Call.Return(inactiveAssetsResponse, err)
	return _c
}

func (_c *TaskInstancesClient_ValidateInletsAndOutlets_Call) RunAndReturn(run func(ctx context.Context, taskInstanceId types.UUID) (*api.InactiveAssetsResponse, error)) *TaskInstancesClient_ValidateInletsAndOutlets_Call {
	_c.Call.Return(run)
	return _c
}

// ValidateInletsAndOutletsResponse provides a mock function for the type TaskInstancesClient
func (_mock *TaskInstancesClient) ValidateInletsAndOutletsResponse(ctx context.Context, taskInstanceId types.UUID) (*resty.Response, error) {
	ret := _mock.Called(ctx, taskInstanceId)

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

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

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

// ValidateInletsAndOutletsResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - taskInstanceId types.UUID
func (_e *TaskInstancesClient_Expecter) ValidateInletsAndOutletsResponse(ctx interface{}, taskInstanceId interface{}) *TaskInstancesClient_ValidateInletsAndOutletsResponse_Call {
	return &TaskInstancesClient_ValidateInletsAndOutletsResponse_Call{Call: _e.mock.On("ValidateInletsAndOutletsResponse", ctx, taskInstanceId)}
}

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

func (_c *TaskInstancesClient_ValidateInletsAndOutletsResponse_Call) Return(response *resty.Response, err error) *TaskInstancesClient_ValidateInletsAndOutletsResponse_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *TaskInstancesClient_ValidateInletsAndOutletsResponse_Call) RunAndReturn(run func(ctx context.Context, taskInstanceId types.UUID) (*resty.Response, error)) *TaskInstancesClient_ValidateInletsAndOutletsResponse_Call {
	_c.Call.Return(run)
	return _c
}
