// Code generated by MockGen. DO NOT EDIT.
// Source: ../../../module/agent2kas_tunnel/router/tracker.go
//
// Generated by this command:
//
//	mockgen -typed -source ../../../module/agent2kas_tunnel/router/tracker.go -destination tracker.go -package mock_agent2kas_router
//

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

import (
	context "context"
	reflect "reflect"
	time "time"

	api "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/api"
	router "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/module/agent2kas_tunnel/router"
	nettool "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/tool/nettool"
	gomock "go.uber.org/mock/gomock"
)

// MockQuerier is a mock of Querier interface.
type MockQuerier struct {
	ctrl     *gomock.Controller
	recorder *MockQuerierMockRecorder
	isgomock struct{}
}

// MockQuerierMockRecorder is the mock recorder for MockQuerier.
type MockQuerierMockRecorder struct {
	mock *MockQuerier
}

// NewMockQuerier creates a new mock instance.
func NewMockQuerier(ctrl *gomock.Controller) *MockQuerier {
	mock := &MockQuerier{ctrl: ctrl}
	mock.recorder = &MockQuerierMockRecorder{mock}
	return mock
}

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

// KASURLsByAgentKey mocks base method.
func (m *MockQuerier) KASURLsByAgentKey(ctx context.Context, agentKey api.AgentKey) ([]nettool.MultiURL, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "KASURLsByAgentKey", ctx, agentKey)
	ret0, _ := ret[0].([]nettool.MultiURL)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// KASURLsByAgentKey indicates an expected call of KASURLsByAgentKey.
func (mr *MockQuerierMockRecorder) KASURLsByAgentKey(ctx, agentKey any) *MockQuerierKASURLsByAgentKeyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KASURLsByAgentKey", reflect.TypeOf((*MockQuerier)(nil).KASURLsByAgentKey), ctx, agentKey)
	return &MockQuerierKASURLsByAgentKeyCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockQuerierKASURLsByAgentKeyCall) Return(arg0 []nettool.MultiURL, arg1 error) *MockQuerierKASURLsByAgentKeyCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQuerierKASURLsByAgentKeyCall) Do(f func(context.Context, api.AgentKey) ([]nettool.MultiURL, error)) *MockQuerierKASURLsByAgentKeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQuerierKASURLsByAgentKeyCall) DoAndReturn(f func(context.Context, api.AgentKey) ([]nettool.MultiURL, error)) *MockQuerierKASURLsByAgentKeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockRegistrationBuilder is a mock of RegistrationBuilder interface.
type MockRegistrationBuilder struct {
	ctrl     *gomock.Controller
	recorder *MockRegistrationBuilderMockRecorder
	isgomock struct{}
}

// MockRegistrationBuilderMockRecorder is the mock recorder for MockRegistrationBuilder.
type MockRegistrationBuilderMockRecorder struct {
	mock *MockRegistrationBuilder
}

// NewMockRegistrationBuilder creates a new mock instance.
func NewMockRegistrationBuilder(ctrl *gomock.Controller) *MockRegistrationBuilder {
	mock := &MockRegistrationBuilder{ctrl: ctrl}
	mock.recorder = &MockRegistrationBuilderMockRecorder{mock}
	return mock
}

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

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

// Do indicates an expected call of Do.
func (mr *MockRegistrationBuilderMockRecorder) Do(arg0 any) *MockRegistrationBuilderDoCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Do", reflect.TypeOf((*MockRegistrationBuilder)(nil).Do), arg0)
	return &MockRegistrationBuilderDoCall{Call: call}
}

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

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

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

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

// Refresh mocks base method.
func (m *MockRegistrationBuilder) Refresh(ttl time.Duration, agentKeys ...api.AgentKey) {
	m.ctrl.T.Helper()
	varargs := []any{ttl}
	for _, a := range agentKeys {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Refresh", varargs...)
}

// Refresh indicates an expected call of Refresh.
func (mr *MockRegistrationBuilderMockRecorder) Refresh(ttl any, agentKeys ...any) *MockRegistrationBuilderRefreshCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ttl}, agentKeys...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Refresh", reflect.TypeOf((*MockRegistrationBuilder)(nil).Refresh), varargs...)
	return &MockRegistrationBuilderRefreshCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRegistrationBuilderRefreshCall) Return() *MockRegistrationBuilderRefreshCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRegistrationBuilderRefreshCall) Do(f func(time.Duration, ...api.AgentKey)) *MockRegistrationBuilderRefreshCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRegistrationBuilderRefreshCall) DoAndReturn(f func(time.Duration, ...api.AgentKey)) *MockRegistrationBuilderRefreshCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Register mocks base method.
func (m *MockRegistrationBuilder) Register(ttl time.Duration, agentKeys ...api.AgentKey) {
	m.ctrl.T.Helper()
	varargs := []any{ttl}
	for _, a := range agentKeys {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Register", varargs...)
}

// Register indicates an expected call of Register.
func (mr *MockRegistrationBuilderMockRecorder) Register(ttl any, agentKeys ...any) *MockRegistrationBuilderRegisterCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ttl}, agentKeys...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Register", reflect.TypeOf((*MockRegistrationBuilder)(nil).Register), varargs...)
	return &MockRegistrationBuilderRegisterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRegistrationBuilderRegisterCall) Return() *MockRegistrationBuilderRegisterCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRegistrationBuilderRegisterCall) Do(f func(time.Duration, ...api.AgentKey)) *MockRegistrationBuilderRegisterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRegistrationBuilderRegisterCall) DoAndReturn(f func(time.Duration, ...api.AgentKey)) *MockRegistrationBuilderRegisterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Unregister mocks base method.
func (m *MockRegistrationBuilder) Unregister(agentKeys ...api.AgentKey) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range agentKeys {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Unregister", varargs...)
}

// Unregister indicates an expected call of Unregister.
func (mr *MockRegistrationBuilderMockRecorder) Unregister(agentKeys ...any) *MockRegistrationBuilderUnregisterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unregister", reflect.TypeOf((*MockRegistrationBuilder)(nil).Unregister), agentKeys...)
	return &MockRegistrationBuilderUnregisterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRegistrationBuilderUnregisterCall) Return() *MockRegistrationBuilderUnregisterCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRegistrationBuilderUnregisterCall) Do(f func(...api.AgentKey)) *MockRegistrationBuilderUnregisterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRegistrationBuilderUnregisterCall) DoAndReturn(f func(...api.AgentKey)) *MockRegistrationBuilderUnregisterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockRegisterer is a mock of Registerer interface.
type MockRegisterer struct {
	ctrl     *gomock.Controller
	recorder *MockRegistererMockRecorder
	isgomock struct{}
}

// MockRegistererMockRecorder is the mock recorder for MockRegisterer.
type MockRegistererMockRecorder struct {
	mock *MockRegisterer
}

// NewMockRegisterer creates a new mock instance.
func NewMockRegisterer(ctrl *gomock.Controller) *MockRegisterer {
	mock := &MockRegisterer{ctrl: ctrl}
	mock.recorder = &MockRegistererMockRecorder{mock}
	return mock
}

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

// GC mocks base method.
func (m *MockRegisterer) GC(ctx context.Context, agentKeys []api.AgentKey) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GC", ctx, agentKeys)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GC indicates an expected call of GC.
func (mr *MockRegistererMockRecorder) GC(ctx, agentKeys any) *MockRegistererGCCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GC", reflect.TypeOf((*MockRegisterer)(nil).GC), ctx, agentKeys)
	return &MockRegistererGCCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockRegistererGCCall) Do(f func(context.Context, []api.AgentKey) (int, error)) *MockRegistererGCCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRegistererGCCall) DoAndReturn(f func(context.Context, []api.AgentKey) (int, error)) *MockRegistererGCCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RegistrationBuilder mocks base method.
func (m *MockRegisterer) RegistrationBuilder() router.RegistrationBuilder {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegistrationBuilder")
	ret0, _ := ret[0].(router.RegistrationBuilder)
	return ret0
}

// RegistrationBuilder indicates an expected call of RegistrationBuilder.
func (mr *MockRegistererMockRecorder) RegistrationBuilder() *MockRegistererRegistrationBuilderCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegistrationBuilder", reflect.TypeOf((*MockRegisterer)(nil).RegistrationBuilder))
	return &MockRegistererRegistrationBuilderCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRegistererRegistrationBuilderCall) Return(arg0 router.RegistrationBuilder) *MockRegistererRegistrationBuilderCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRegistererRegistrationBuilderCall) Do(f func() router.RegistrationBuilder) *MockRegistererRegistrationBuilderCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRegistererRegistrationBuilderCall) DoAndReturn(f func() router.RegistrationBuilder) *MockRegistererRegistrationBuilderCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockTrackerGCCall) Do(f func(context.Context, []api.AgentKey) (int, error)) *MockTrackerGCCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTrackerGCCall) DoAndReturn(f func(context.Context, []api.AgentKey) (int, error)) *MockTrackerGCCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

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

// Return rewrite *gomock.Call.Return
func (c *MockTrackerKASURLsByAgentKeyCall) Return(arg0 []nettool.MultiURL, arg1 error) *MockTrackerKASURLsByAgentKeyCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockTrackerKASURLsByAgentKeyCall) Do(f func(context.Context, api.AgentKey) ([]nettool.MultiURL, error)) *MockTrackerKASURLsByAgentKeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTrackerKASURLsByAgentKeyCall) DoAndReturn(f func(context.Context, api.AgentKey) ([]nettool.MultiURL, error)) *MockTrackerKASURLsByAgentKeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

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

// Return rewrite *gomock.Call.Return
func (c *MockTrackerRegistrationBuilderCall) Return(arg0 router.RegistrationBuilder) *MockTrackerRegistrationBuilderCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockTrackerRegistrationBuilderCall) Do(f func() router.RegistrationBuilder) *MockTrackerRegistrationBuilderCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTrackerRegistrationBuilderCall) DoAndReturn(f func() router.RegistrationBuilder) *MockTrackerRegistrationBuilderCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
