// Code generated by MockGen. DO NOT EDIT.
// Source: gitlab.com/gitlab-org/api/client-go (interfaces: ClusterAgentsServiceInterface)
//
// Generated by this command:
//
//	mockgen -typed -destination=cluster_agents_mock.go -package=testing gitlab.com/gitlab-org/api/client-go ClusterAgentsServiceInterface
//

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

import (
	reflect "reflect"

	gitlab "gitlab.com/gitlab-org/api/client-go"
	gomock "go.uber.org/mock/gomock"
)

// MockClusterAgentsServiceInterface is a mock of ClusterAgentsServiceInterface interface.
type MockClusterAgentsServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockClusterAgentsServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockClusterAgentsServiceInterfaceMockRecorder is the mock recorder for MockClusterAgentsServiceInterface.
type MockClusterAgentsServiceInterfaceMockRecorder struct {
	mock *MockClusterAgentsServiceInterface
}

// NewMockClusterAgentsServiceInterface creates a new mock instance.
func NewMockClusterAgentsServiceInterface(ctrl *gomock.Controller) *MockClusterAgentsServiceInterface {
	mock := &MockClusterAgentsServiceInterface{ctrl: ctrl}
	mock.recorder = &MockClusterAgentsServiceInterfaceMockRecorder{mock}
	return mock
}

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

// CreateAgentToken mocks base method.
func (m *MockClusterAgentsServiceInterface) CreateAgentToken(pid any, aid int, opt *gitlab.CreateAgentTokenOptions, options ...gitlab.RequestOptionFunc) (*gitlab.AgentToken, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, aid, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateAgentToken", varargs...)
	ret0, _ := ret[0].(*gitlab.AgentToken)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateAgentToken indicates an expected call of CreateAgentToken.
func (mr *MockClusterAgentsServiceInterfaceMockRecorder) CreateAgentToken(pid, aid, opt any, options ...any) *MockClusterAgentsServiceInterfaceCreateAgentTokenCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, aid, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAgentToken", reflect.TypeOf((*MockClusterAgentsServiceInterface)(nil).CreateAgentToken), varargs...)
	return &MockClusterAgentsServiceInterfaceCreateAgentTokenCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockClusterAgentsServiceInterfaceCreateAgentTokenCall) Return(arg0 *gitlab.AgentToken, arg1 *gitlab.Response, arg2 error) *MockClusterAgentsServiceInterfaceCreateAgentTokenCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterAgentsServiceInterfaceCreateAgentTokenCall) Do(f func(any, int, *gitlab.CreateAgentTokenOptions, ...gitlab.RequestOptionFunc) (*gitlab.AgentToken, *gitlab.Response, error)) *MockClusterAgentsServiceInterfaceCreateAgentTokenCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterAgentsServiceInterfaceCreateAgentTokenCall) DoAndReturn(f func(any, int, *gitlab.CreateAgentTokenOptions, ...gitlab.RequestOptionFunc) (*gitlab.AgentToken, *gitlab.Response, error)) *MockClusterAgentsServiceInterfaceCreateAgentTokenCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// DeleteAgent mocks base method.
func (m *MockClusterAgentsServiceInterface) DeleteAgent(pid any, id int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, id}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAgent", varargs...)
	ret0, _ := ret[0].(*gitlab.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAgent indicates an expected call of DeleteAgent.
func (mr *MockClusterAgentsServiceInterfaceMockRecorder) DeleteAgent(pid, id any, options ...any) *MockClusterAgentsServiceInterfaceDeleteAgentCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, id}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAgent", reflect.TypeOf((*MockClusterAgentsServiceInterface)(nil).DeleteAgent), varargs...)
	return &MockClusterAgentsServiceInterfaceDeleteAgentCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockClusterAgentsServiceInterfaceDeleteAgentCall) Return(arg0 *gitlab.Response, arg1 error) *MockClusterAgentsServiceInterfaceDeleteAgentCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterAgentsServiceInterfaceDeleteAgentCall) Do(f func(any, int, ...gitlab.RequestOptionFunc) (*gitlab.Response, error)) *MockClusterAgentsServiceInterfaceDeleteAgentCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterAgentsServiceInterfaceDeleteAgentCall) DoAndReturn(f func(any, int, ...gitlab.RequestOptionFunc) (*gitlab.Response, error)) *MockClusterAgentsServiceInterfaceDeleteAgentCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetAgent mocks base method.
func (m *MockClusterAgentsServiceInterface) GetAgent(pid any, id int, options ...gitlab.RequestOptionFunc) (*gitlab.Agent, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, id}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAgent", varargs...)
	ret0, _ := ret[0].(*gitlab.Agent)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetAgent indicates an expected call of GetAgent.
func (mr *MockClusterAgentsServiceInterfaceMockRecorder) GetAgent(pid, id any, options ...any) *MockClusterAgentsServiceInterfaceGetAgentCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, id}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAgent", reflect.TypeOf((*MockClusterAgentsServiceInterface)(nil).GetAgent), varargs...)
	return &MockClusterAgentsServiceInterfaceGetAgentCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockClusterAgentsServiceInterfaceGetAgentCall) Return(arg0 *gitlab.Agent, arg1 *gitlab.Response, arg2 error) *MockClusterAgentsServiceInterfaceGetAgentCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterAgentsServiceInterfaceGetAgentCall) Do(f func(any, int, ...gitlab.RequestOptionFunc) (*gitlab.Agent, *gitlab.Response, error)) *MockClusterAgentsServiceInterfaceGetAgentCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterAgentsServiceInterfaceGetAgentCall) DoAndReturn(f func(any, int, ...gitlab.RequestOptionFunc) (*gitlab.Agent, *gitlab.Response, error)) *MockClusterAgentsServiceInterfaceGetAgentCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetAgentToken mocks base method.
func (m *MockClusterAgentsServiceInterface) GetAgentToken(pid any, aid, id int, options ...gitlab.RequestOptionFunc) (*gitlab.AgentToken, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, aid, id}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAgentToken", varargs...)
	ret0, _ := ret[0].(*gitlab.AgentToken)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetAgentToken indicates an expected call of GetAgentToken.
func (mr *MockClusterAgentsServiceInterfaceMockRecorder) GetAgentToken(pid, aid, id any, options ...any) *MockClusterAgentsServiceInterfaceGetAgentTokenCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, aid, id}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAgentToken", reflect.TypeOf((*MockClusterAgentsServiceInterface)(nil).GetAgentToken), varargs...)
	return &MockClusterAgentsServiceInterfaceGetAgentTokenCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockClusterAgentsServiceInterfaceGetAgentTokenCall) Return(arg0 *gitlab.AgentToken, arg1 *gitlab.Response, arg2 error) *MockClusterAgentsServiceInterfaceGetAgentTokenCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterAgentsServiceInterfaceGetAgentTokenCall) Do(f func(any, int, int, ...gitlab.RequestOptionFunc) (*gitlab.AgentToken, *gitlab.Response, error)) *MockClusterAgentsServiceInterfaceGetAgentTokenCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterAgentsServiceInterfaceGetAgentTokenCall) DoAndReturn(f func(any, int, int, ...gitlab.RequestOptionFunc) (*gitlab.AgentToken, *gitlab.Response, error)) *MockClusterAgentsServiceInterfaceGetAgentTokenCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListAgentTokens mocks base method.
func (m *MockClusterAgentsServiceInterface) ListAgentTokens(pid any, aid int, opt *gitlab.ListAgentTokensOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.AgentToken, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, aid, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAgentTokens", varargs...)
	ret0, _ := ret[0].([]*gitlab.AgentToken)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListAgentTokens indicates an expected call of ListAgentTokens.
func (mr *MockClusterAgentsServiceInterfaceMockRecorder) ListAgentTokens(pid, aid, opt any, options ...any) *MockClusterAgentsServiceInterfaceListAgentTokensCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, aid, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAgentTokens", reflect.TypeOf((*MockClusterAgentsServiceInterface)(nil).ListAgentTokens), varargs...)
	return &MockClusterAgentsServiceInterfaceListAgentTokensCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockClusterAgentsServiceInterfaceListAgentTokensCall) Return(arg0 []*gitlab.AgentToken, arg1 *gitlab.Response, arg2 error) *MockClusterAgentsServiceInterfaceListAgentTokensCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterAgentsServiceInterfaceListAgentTokensCall) Do(f func(any, int, *gitlab.ListAgentTokensOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.AgentToken, *gitlab.Response, error)) *MockClusterAgentsServiceInterfaceListAgentTokensCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterAgentsServiceInterfaceListAgentTokensCall) DoAndReturn(f func(any, int, *gitlab.ListAgentTokensOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.AgentToken, *gitlab.Response, error)) *MockClusterAgentsServiceInterfaceListAgentTokensCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListAgents mocks base method.
func (m *MockClusterAgentsServiceInterface) ListAgents(pid any, opt *gitlab.ListAgentsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Agent, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAgents", varargs...)
	ret0, _ := ret[0].([]*gitlab.Agent)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListAgents indicates an expected call of ListAgents.
func (mr *MockClusterAgentsServiceInterfaceMockRecorder) ListAgents(pid, opt any, options ...any) *MockClusterAgentsServiceInterfaceListAgentsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAgents", reflect.TypeOf((*MockClusterAgentsServiceInterface)(nil).ListAgents), varargs...)
	return &MockClusterAgentsServiceInterfaceListAgentsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockClusterAgentsServiceInterfaceListAgentsCall) Return(arg0 []*gitlab.Agent, arg1 *gitlab.Response, arg2 error) *MockClusterAgentsServiceInterfaceListAgentsCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterAgentsServiceInterfaceListAgentsCall) Do(f func(any, *gitlab.ListAgentsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Agent, *gitlab.Response, error)) *MockClusterAgentsServiceInterfaceListAgentsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterAgentsServiceInterfaceListAgentsCall) DoAndReturn(f func(any, *gitlab.ListAgentsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Agent, *gitlab.Response, error)) *MockClusterAgentsServiceInterfaceListAgentsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RegisterAgent mocks base method.
func (m *MockClusterAgentsServiceInterface) RegisterAgent(pid any, opt *gitlab.RegisterAgentOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Agent, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterAgent", varargs...)
	ret0, _ := ret[0].(*gitlab.Agent)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RegisterAgent indicates an expected call of RegisterAgent.
func (mr *MockClusterAgentsServiceInterfaceMockRecorder) RegisterAgent(pid, opt any, options ...any) *MockClusterAgentsServiceInterfaceRegisterAgentCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterAgent", reflect.TypeOf((*MockClusterAgentsServiceInterface)(nil).RegisterAgent), varargs...)
	return &MockClusterAgentsServiceInterfaceRegisterAgentCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockClusterAgentsServiceInterfaceRegisterAgentCall) Return(arg0 *gitlab.Agent, arg1 *gitlab.Response, arg2 error) *MockClusterAgentsServiceInterfaceRegisterAgentCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterAgentsServiceInterfaceRegisterAgentCall) Do(f func(any, *gitlab.RegisterAgentOptions, ...gitlab.RequestOptionFunc) (*gitlab.Agent, *gitlab.Response, error)) *MockClusterAgentsServiceInterfaceRegisterAgentCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterAgentsServiceInterfaceRegisterAgentCall) DoAndReturn(f func(any, *gitlab.RegisterAgentOptions, ...gitlab.RequestOptionFunc) (*gitlab.Agent, *gitlab.Response, error)) *MockClusterAgentsServiceInterfaceRegisterAgentCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RevokeAgentToken mocks base method.
func (m *MockClusterAgentsServiceInterface) RevokeAgentToken(pid any, aid, id int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, aid, id}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RevokeAgentToken", varargs...)
	ret0, _ := ret[0].(*gitlab.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RevokeAgentToken indicates an expected call of RevokeAgentToken.
func (mr *MockClusterAgentsServiceInterfaceMockRecorder) RevokeAgentToken(pid, aid, id any, options ...any) *MockClusterAgentsServiceInterfaceRevokeAgentTokenCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, aid, id}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeAgentToken", reflect.TypeOf((*MockClusterAgentsServiceInterface)(nil).RevokeAgentToken), varargs...)
	return &MockClusterAgentsServiceInterfaceRevokeAgentTokenCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockClusterAgentsServiceInterfaceRevokeAgentTokenCall) Return(arg0 *gitlab.Response, arg1 error) *MockClusterAgentsServiceInterfaceRevokeAgentTokenCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterAgentsServiceInterfaceRevokeAgentTokenCall) Do(f func(any, int, int, ...gitlab.RequestOptionFunc) (*gitlab.Response, error)) *MockClusterAgentsServiceInterfaceRevokeAgentTokenCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterAgentsServiceInterfaceRevokeAgentTokenCall) DoAndReturn(f func(any, int, int, ...gitlab.RequestOptionFunc) (*gitlab.Response, error)) *MockClusterAgentsServiceInterfaceRevokeAgentTokenCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
