// Code generated by MockGen. DO NOT EDIT.
// Source: gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/module/agent_tracker (interfaces: Tracker)
//
// Generated by this command:
//
//	mockgen -typed -destination tracker.go gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/module/agent_tracker Tracker
//

// Package mock_agent_tracker is a generated GoMock package.
package mock_agent_tracker

import (
	context "context"
	iter "iter"
	reflect "reflect"

	agent_tracker "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/module/agent_tracker"
	gomock "go.uber.org/mock/gomock"
)

// MockTracker is a mock of Tracker interface.
type MockTracker struct {
	ctrl     *gomock.Controller
	recorder *MockTrackerMockRecorder
	isgomock struct{}
}

// MockTrackerMockRecorder is the mock recorder for MockTracker.
type MockTrackerMockRecorder struct {
	mock *MockTracker
}

// NewMockTracker creates a new mock instance.
func NewMockTracker(ctrl *gomock.Controller) *MockTracker {
	mock := &MockTracker{ctrl: ctrl}
	mock.recorder = &MockTrackerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTracker) EXPECT() *MockTrackerMockRecorder {
	return m.recorder
}

// CountAgentksByAgentVersions mocks base method.
func (m *MockTracker) CountAgentksByAgentVersions(ctx context.Context) (map[string]int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountAgentksByAgentVersions", ctx)
	ret0, _ := ret[0].(map[string]int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountAgentksByAgentVersions indicates an expected call of CountAgentksByAgentVersions.
func (mr *MockTrackerMockRecorder) CountAgentksByAgentVersions(ctx any) *MockTrackerCountAgentksByAgentVersionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountAgentksByAgentVersions", reflect.TypeOf((*MockTracker)(nil).CountAgentksByAgentVersions), ctx)
	return &MockTrackerCountAgentksByAgentVersionsCall{Call: call}
}

// MockTrackerCountAgentksByAgentVersionsCall wrap *gomock.Call
type MockTrackerCountAgentksByAgentVersionsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockTrackerCountAgentksByAgentVersionsCall) Return(arg0 map[string]int64, arg1 error) *MockTrackerCountAgentksByAgentVersionsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockTrackerCountAgentksByAgentVersionsCall) Do(f func(context.Context) (map[string]int64, error)) *MockTrackerCountAgentksByAgentVersionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTrackerCountAgentksByAgentVersionsCall) DoAndReturn(f func(context.Context) (map[string]int64, error)) *MockTrackerCountAgentksByAgentVersionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetAgentkConnectionsByID mocks base method.
func (m *MockTracker) GetAgentkConnectionsByID(ctx context.Context, agentID int64) iter.Seq[*agent_tracker.ConnectedAgentkInfo] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAgentkConnectionsByID", ctx, agentID)
	ret0, _ := ret[0].(iter.Seq[*agent_tracker.ConnectedAgentkInfo])
	return ret0
}

// GetAgentkConnectionsByID indicates an expected call of GetAgentkConnectionsByID.
func (mr *MockTrackerMockRecorder) GetAgentkConnectionsByID(ctx, agentID any) *MockTrackerGetAgentkConnectionsByIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAgentkConnectionsByID", reflect.TypeOf((*MockTracker)(nil).GetAgentkConnectionsByID), ctx, agentID)
	return &MockTrackerGetAgentkConnectionsByIDCall{Call: call}
}

// MockTrackerGetAgentkConnectionsByIDCall wrap *gomock.Call
type MockTrackerGetAgentkConnectionsByIDCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockTrackerGetAgentkConnectionsByIDCall) Return(arg0 iter.Seq[*agent_tracker.ConnectedAgentkInfo]) *MockTrackerGetAgentkConnectionsByIDCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockTrackerGetAgentkConnectionsByIDCall) Do(f func(context.Context, int64) iter.Seq[*agent_tracker.ConnectedAgentkInfo]) *MockTrackerGetAgentkConnectionsByIDCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTrackerGetAgentkConnectionsByIDCall) DoAndReturn(f func(context.Context, int64) iter.Seq[*agent_tracker.ConnectedAgentkInfo]) *MockTrackerGetAgentkConnectionsByIDCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetAgentwConnectionsByID mocks base method.
func (m *MockTracker) GetAgentwConnectionsByID(ctx context.Context, agentID int64) iter.Seq[*agent_tracker.ConnectedAgentwInfo] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAgentwConnectionsByID", ctx, agentID)
	ret0, _ := ret[0].(iter.Seq[*agent_tracker.ConnectedAgentwInfo])
	return ret0
}

// GetAgentwConnectionsByID indicates an expected call of GetAgentwConnectionsByID.
func (mr *MockTrackerMockRecorder) GetAgentwConnectionsByID(ctx, agentID any) *MockTrackerGetAgentwConnectionsByIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAgentwConnectionsByID", reflect.TypeOf((*MockTracker)(nil).GetAgentwConnectionsByID), ctx, agentID)
	return &MockTrackerGetAgentwConnectionsByIDCall{Call: call}
}

// MockTrackerGetAgentwConnectionsByIDCall wrap *gomock.Call
type MockTrackerGetAgentwConnectionsByIDCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockTrackerGetAgentwConnectionsByIDCall) Return(arg0 iter.Seq[*agent_tracker.ConnectedAgentwInfo]) *MockTrackerGetAgentwConnectionsByIDCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockTrackerGetAgentwConnectionsByIDCall) Do(f func(context.Context, int64) iter.Seq[*agent_tracker.ConnectedAgentwInfo]) *MockTrackerGetAgentwConnectionsByIDCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTrackerGetAgentwConnectionsByIDCall) DoAndReturn(f func(context.Context, int64) iter.Seq[*agent_tracker.ConnectedAgentwInfo]) *MockTrackerGetAgentwConnectionsByIDCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetConnectedAgentsCount mocks base method.
func (m *MockTracker) GetConnectedAgentsCount(ctx context.Context) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConnectedAgentsCount", ctx)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConnectedAgentsCount indicates an expected call of GetConnectedAgentsCount.
func (mr *MockTrackerMockRecorder) GetConnectedAgentsCount(ctx any) *MockTrackerGetConnectedAgentsCountCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnectedAgentsCount", reflect.TypeOf((*MockTracker)(nil).GetConnectedAgentsCount), ctx)
	return &MockTrackerGetConnectedAgentsCountCall{Call: call}
}

// MockTrackerGetConnectedAgentsCountCall wrap *gomock.Call
type MockTrackerGetConnectedAgentsCountCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockTrackerGetConnectedAgentsCountCall) Return(arg0 int64, arg1 error) *MockTrackerGetConnectedAgentsCountCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockTrackerGetConnectedAgentsCountCall) Do(f func(context.Context) (int64, error)) *MockTrackerGetConnectedAgentsCountCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTrackerGetConnectedAgentsCountCall) DoAndReturn(f func(context.Context) (int64, error)) *MockTrackerGetConnectedAgentsCountCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetRunnerControllerConnectionsByID mocks base method.
func (m *MockTracker) GetRunnerControllerConnectionsByID(ctx context.Context, agentID int64) iter.Seq[*agent_tracker.ConnectedRunnerControllerInfo] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRunnerControllerConnectionsByID", ctx, agentID)
	ret0, _ := ret[0].(iter.Seq[*agent_tracker.ConnectedRunnerControllerInfo])
	return ret0
}

// GetRunnerControllerConnectionsByID indicates an expected call of GetRunnerControllerConnectionsByID.
func (mr *MockTrackerMockRecorder) GetRunnerControllerConnectionsByID(ctx, agentID any) *MockTrackerGetRunnerControllerConnectionsByIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRunnerControllerConnectionsByID", reflect.TypeOf((*MockTracker)(nil).GetRunnerControllerConnectionsByID), ctx, agentID)
	return &MockTrackerGetRunnerControllerConnectionsByIDCall{Call: call}
}

// MockTrackerGetRunnerControllerConnectionsByIDCall wrap *gomock.Call
type MockTrackerGetRunnerControllerConnectionsByIDCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockTrackerGetRunnerControllerConnectionsByIDCall) Return(arg0 iter.Seq[*agent_tracker.ConnectedRunnerControllerInfo]) *MockTrackerGetRunnerControllerConnectionsByIDCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockTrackerGetRunnerControllerConnectionsByIDCall) Do(f func(context.Context, int64) iter.Seq[*agent_tracker.ConnectedRunnerControllerInfo]) *MockTrackerGetRunnerControllerConnectionsByIDCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTrackerGetRunnerControllerConnectionsByIDCall) DoAndReturn(f func(context.Context, int64) iter.Seq[*agent_tracker.ConnectedRunnerControllerInfo]) *MockTrackerGetRunnerControllerConnectionsByIDCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RegisterAgentkExpiring mocks base method.
func (m *MockTracker) RegisterAgentkExpiring(ctx context.Context, info *agent_tracker.ConnectedAgentkInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterAgentkExpiring", ctx, info)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterAgentkExpiring indicates an expected call of RegisterAgentkExpiring.
func (mr *MockTrackerMockRecorder) RegisterAgentkExpiring(ctx, info any) *MockTrackerRegisterAgentkExpiringCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterAgentkExpiring", reflect.TypeOf((*MockTracker)(nil).RegisterAgentkExpiring), ctx, info)
	return &MockTrackerRegisterAgentkExpiringCall{Call: call}
}

// MockTrackerRegisterAgentkExpiringCall wrap *gomock.Call
type MockTrackerRegisterAgentkExpiringCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockTrackerRegisterAgentkExpiringCall) Return(arg0 error) *MockTrackerRegisterAgentkExpiringCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockTrackerRegisterAgentkExpiringCall) Do(f func(context.Context, *agent_tracker.ConnectedAgentkInfo) error) *MockTrackerRegisterAgentkExpiringCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTrackerRegisterAgentkExpiringCall) DoAndReturn(f func(context.Context, *agent_tracker.ConnectedAgentkInfo) error) *MockTrackerRegisterAgentkExpiringCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RegisterAgentwExpiring mocks base method.
func (m *MockTracker) RegisterAgentwExpiring(ctx context.Context, info *agent_tracker.ConnectedAgentwInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterAgentwExpiring", ctx, info)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterAgentwExpiring indicates an expected call of RegisterAgentwExpiring.
func (mr *MockTrackerMockRecorder) RegisterAgentwExpiring(ctx, info any) *MockTrackerRegisterAgentwExpiringCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterAgentwExpiring", reflect.TypeOf((*MockTracker)(nil).RegisterAgentwExpiring), ctx, info)
	return &MockTrackerRegisterAgentwExpiringCall{Call: call}
}

// MockTrackerRegisterAgentwExpiringCall wrap *gomock.Call
type MockTrackerRegisterAgentwExpiringCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockTrackerRegisterAgentwExpiringCall) Return(arg0 error) *MockTrackerRegisterAgentwExpiringCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockTrackerRegisterAgentwExpiringCall) Do(f func(context.Context, *agent_tracker.ConnectedAgentwInfo) error) *MockTrackerRegisterAgentwExpiringCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTrackerRegisterAgentwExpiringCall) DoAndReturn(f func(context.Context, *agent_tracker.ConnectedAgentwInfo) error) *MockTrackerRegisterAgentwExpiringCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RegisterRunnerControllerExpiring mocks base method.
func (m *MockTracker) RegisterRunnerControllerExpiring(ctx context.Context, info *agent_tracker.ConnectedRunnerControllerInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterRunnerControllerExpiring", ctx, info)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterRunnerControllerExpiring indicates an expected call of RegisterRunnerControllerExpiring.
func (mr *MockTrackerMockRecorder) RegisterRunnerControllerExpiring(ctx, info any) *MockTrackerRegisterRunnerControllerExpiringCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterRunnerControllerExpiring", reflect.TypeOf((*MockTracker)(nil).RegisterRunnerControllerExpiring), ctx, info)
	return &MockTrackerRegisterRunnerControllerExpiringCall{Call: call}
}

// MockTrackerRegisterRunnerControllerExpiringCall wrap *gomock.Call
type MockTrackerRegisterRunnerControllerExpiringCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockTrackerRegisterRunnerControllerExpiringCall) Return(arg0 error) *MockTrackerRegisterRunnerControllerExpiringCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockTrackerRegisterRunnerControllerExpiringCall) Do(f func(context.Context, *agent_tracker.ConnectedRunnerControllerInfo) error) *MockTrackerRegisterRunnerControllerExpiringCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTrackerRegisterRunnerControllerExpiringCall) DoAndReturn(f func(context.Context, *agent_tracker.ConnectedRunnerControllerInfo) error) *MockTrackerRegisterRunnerControllerExpiringCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Run mocks base method.
func (m *MockTracker) Run(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Run", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

// Run indicates an expected call of Run.
func (mr *MockTrackerMockRecorder) Run(ctx any) *MockTrackerRunCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockTracker)(nil).Run), ctx)
	return &MockTrackerRunCall{Call: call}
}

// MockTrackerRunCall wrap *gomock.Call
type MockTrackerRunCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockTrackerRunCall) Return(arg0 error) *MockTrackerRunCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockTrackerRunCall) Do(f func(context.Context) error) *MockTrackerRunCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTrackerRunCall) DoAndReturn(f func(context.Context) error) *MockTrackerRunCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UnregisterAgentk mocks base method.
func (m *MockTracker) UnregisterAgentk(ctx context.Context, info *agent_tracker.DisconnectAgentkInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnregisterAgentk", ctx, info)
	ret0, _ := ret[0].(error)
	return ret0
}

// UnregisterAgentk indicates an expected call of UnregisterAgentk.
func (mr *MockTrackerMockRecorder) UnregisterAgentk(ctx, info any) *MockTrackerUnregisterAgentkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterAgentk", reflect.TypeOf((*MockTracker)(nil).UnregisterAgentk), ctx, info)
	return &MockTrackerUnregisterAgentkCall{Call: call}
}

// MockTrackerUnregisterAgentkCall wrap *gomock.Call
type MockTrackerUnregisterAgentkCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockTrackerUnregisterAgentkCall) Return(arg0 error) *MockTrackerUnregisterAgentkCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockTrackerUnregisterAgentkCall) Do(f func(context.Context, *agent_tracker.DisconnectAgentkInfo) error) *MockTrackerUnregisterAgentkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTrackerUnregisterAgentkCall) DoAndReturn(f func(context.Context, *agent_tracker.DisconnectAgentkInfo) error) *MockTrackerUnregisterAgentkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UnregisterAgentw mocks base method.
func (m *MockTracker) UnregisterAgentw(ctx context.Context, info *agent_tracker.DisconnectAgentwInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnregisterAgentw", ctx, info)
	ret0, _ := ret[0].(error)
	return ret0
}

// UnregisterAgentw indicates an expected call of UnregisterAgentw.
func (mr *MockTrackerMockRecorder) UnregisterAgentw(ctx, info any) *MockTrackerUnregisterAgentwCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterAgentw", reflect.TypeOf((*MockTracker)(nil).UnregisterAgentw), ctx, info)
	return &MockTrackerUnregisterAgentwCall{Call: call}
}

// MockTrackerUnregisterAgentwCall wrap *gomock.Call
type MockTrackerUnregisterAgentwCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockTrackerUnregisterAgentwCall) Return(arg0 error) *MockTrackerUnregisterAgentwCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockTrackerUnregisterAgentwCall) Do(f func(context.Context, *agent_tracker.DisconnectAgentwInfo) error) *MockTrackerUnregisterAgentwCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTrackerUnregisterAgentwCall) DoAndReturn(f func(context.Context, *agent_tracker.DisconnectAgentwInfo) error) *MockTrackerUnregisterAgentwCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UnregisterRunnerController mocks base method.
func (m *MockTracker) UnregisterRunnerController(ctx context.Context, info *agent_tracker.DisconnectRunnerControllerInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnregisterRunnerController", ctx, info)
	ret0, _ := ret[0].(error)
	return ret0
}

// UnregisterRunnerController indicates an expected call of UnregisterRunnerController.
func (mr *MockTrackerMockRecorder) UnregisterRunnerController(ctx, info any) *MockTrackerUnregisterRunnerControllerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterRunnerController", reflect.TypeOf((*MockTracker)(nil).UnregisterRunnerController), ctx, info)
	return &MockTrackerUnregisterRunnerControllerCall{Call: call}
}

// MockTrackerUnregisterRunnerControllerCall wrap *gomock.Call
type MockTrackerUnregisterRunnerControllerCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockTrackerUnregisterRunnerControllerCall) Return(arg0 error) *MockTrackerUnregisterRunnerControllerCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockTrackerUnregisterRunnerControllerCall) Do(f func(context.Context, *agent_tracker.DisconnectRunnerControllerInfo) error) *MockTrackerUnregisterRunnerControllerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTrackerUnregisterRunnerControllerCall) DoAndReturn(f func(context.Context, *agent_tracker.DisconnectRunnerControllerInfo) error) *MockTrackerUnregisterRunnerControllerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
