// Code generated by MockGen. DO NOT EDIT.
// Source: gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v16/internal/module/gitlab_access/rpc (interfaces: GitlabAccessClient,GitlabAccess_MakeRequestClient)
//
// Generated by this command:
//
//	mockgen -typed -destination gitlab_access.go -package mock_gitlab_access gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v16/internal/module/gitlab_access/rpc GitlabAccessClient,GitlabAccess_MakeRequestClient
//

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

import (
	context "context"
	reflect "reflect"

	rpc "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v16/internal/module/gitlab_access/rpc"
	grpctool "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v16/internal/tool/grpctool"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"
)

// MockGitlabAccessClient is a mock of GitlabAccessClient interface.
type MockGitlabAccessClient struct {
	ctrl     *gomock.Controller
	recorder *MockGitlabAccessClientMockRecorder
}

// MockGitlabAccessClientMockRecorder is the mock recorder for MockGitlabAccessClient.
type MockGitlabAccessClientMockRecorder struct {
	mock *MockGitlabAccessClient
}

// NewMockGitlabAccessClient creates a new mock instance.
func NewMockGitlabAccessClient(ctrl *gomock.Controller) *MockGitlabAccessClient {
	mock := &MockGitlabAccessClient{ctrl: ctrl}
	mock.recorder = &MockGitlabAccessClientMockRecorder{mock}
	return mock
}

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

// MakeRequest mocks base method.
func (m *MockGitlabAccessClient) MakeRequest(arg0 context.Context, arg1 ...grpc.CallOption) (rpc.GitlabAccess_MakeRequestClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MakeRequest", varargs...)
	ret0, _ := ret[0].(rpc.GitlabAccess_MakeRequestClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MakeRequest indicates an expected call of MakeRequest.
func (mr *MockGitlabAccessClientMockRecorder) MakeRequest(arg0 any, arg1 ...any) *MockGitlabAccessClientMakeRequestCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeRequest", reflect.TypeOf((*MockGitlabAccessClient)(nil).MakeRequest), varargs...)
	return &MockGitlabAccessClientMakeRequestCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitlabAccessClientMakeRequestCall) Return(arg0 rpc.GitlabAccess_MakeRequestClient, arg1 error) *MockGitlabAccessClientMakeRequestCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitlabAccessClientMakeRequestCall) Do(f func(context.Context, ...grpc.CallOption) (rpc.GitlabAccess_MakeRequestClient, error)) *MockGitlabAccessClientMakeRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitlabAccessClientMakeRequestCall) DoAndReturn(f func(context.Context, ...grpc.CallOption) (rpc.GitlabAccess_MakeRequestClient, error)) *MockGitlabAccessClientMakeRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGitlabAccess_MakeRequestClient is a mock of GitlabAccess_MakeRequestClient interface.
type MockGitlabAccess_MakeRequestClient struct {
	ctrl     *gomock.Controller
	recorder *MockGitlabAccess_MakeRequestClientMockRecorder
}

// MockGitlabAccess_MakeRequestClientMockRecorder is the mock recorder for MockGitlabAccess_MakeRequestClient.
type MockGitlabAccess_MakeRequestClientMockRecorder struct {
	mock *MockGitlabAccess_MakeRequestClient
}

// NewMockGitlabAccess_MakeRequestClient creates a new mock instance.
func NewMockGitlabAccess_MakeRequestClient(ctrl *gomock.Controller) *MockGitlabAccess_MakeRequestClient {
	mock := &MockGitlabAccess_MakeRequestClient{ctrl: ctrl}
	mock.recorder = &MockGitlabAccess_MakeRequestClientMockRecorder{mock}
	return mock
}

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

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

// CloseSend indicates an expected call of CloseSend.
func (mr *MockGitlabAccess_MakeRequestClientMockRecorder) CloseSend() *MockGitlabAccess_MakeRequestClientCloseSendCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockGitlabAccess_MakeRequestClient)(nil).CloseSend))
	return &MockGitlabAccess_MakeRequestClientCloseSendCall{Call: call}
}

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

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

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

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

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

// Context indicates an expected call of Context.
func (mr *MockGitlabAccess_MakeRequestClientMockRecorder) Context() *MockGitlabAccess_MakeRequestClientContextCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockGitlabAccess_MakeRequestClient)(nil).Context))
	return &MockGitlabAccess_MakeRequestClientContextCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitlabAccess_MakeRequestClientContextCall) Return(arg0 context.Context) *MockGitlabAccess_MakeRequestClientContextCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// Header mocks base method.
func (m *MockGitlabAccess_MakeRequestClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockGitlabAccess_MakeRequestClientMockRecorder) Header() *MockGitlabAccess_MakeRequestClientHeaderCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockGitlabAccess_MakeRequestClient)(nil).Header))
	return &MockGitlabAccess_MakeRequestClientHeaderCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitlabAccess_MakeRequestClientHeaderCall) Return(arg0 metadata.MD, arg1 error) *MockGitlabAccess_MakeRequestClientHeaderCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitlabAccess_MakeRequestClientHeaderCall) Do(f func() (metadata.MD, error)) *MockGitlabAccess_MakeRequestClientHeaderCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitlabAccess_MakeRequestClientHeaderCall) DoAndReturn(f func() (metadata.MD, error)) *MockGitlabAccess_MakeRequestClientHeaderCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Recv mocks base method.
func (m *MockGitlabAccess_MakeRequestClient) Recv() (*grpctool.HttpResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*grpctool.HttpResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockGitlabAccess_MakeRequestClientMockRecorder) Recv() *MockGitlabAccess_MakeRequestClientRecvCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockGitlabAccess_MakeRequestClient)(nil).Recv))
	return &MockGitlabAccess_MakeRequestClientRecvCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitlabAccess_MakeRequestClientRecvCall) Return(arg0 *grpctool.HttpResponse, arg1 error) *MockGitlabAccess_MakeRequestClientRecvCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitlabAccess_MakeRequestClientRecvCall) Do(f func() (*grpctool.HttpResponse, error)) *MockGitlabAccess_MakeRequestClientRecvCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitlabAccess_MakeRequestClientRecvCall) DoAndReturn(f func() (*grpctool.HttpResponse, error)) *MockGitlabAccess_MakeRequestClientRecvCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockGitlabAccess_MakeRequestClientMockRecorder) RecvMsg(arg0 any) *MockGitlabAccess_MakeRequestClientRecvMsgCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockGitlabAccess_MakeRequestClient)(nil).RecvMsg), arg0)
	return &MockGitlabAccess_MakeRequestClientRecvMsgCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockGitlabAccess_MakeRequestClientRecvMsgCall) Do(f func(any) error) *MockGitlabAccess_MakeRequestClientRecvMsgCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitlabAccess_MakeRequestClientRecvMsgCall) DoAndReturn(f func(any) error) *MockGitlabAccess_MakeRequestClientRecvMsgCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Send mocks base method.
func (m *MockGitlabAccess_MakeRequestClient) Send(arg0 *grpctool.HttpRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockGitlabAccess_MakeRequestClientMockRecorder) Send(arg0 any) *MockGitlabAccess_MakeRequestClientSendCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockGitlabAccess_MakeRequestClient)(nil).Send), arg0)
	return &MockGitlabAccess_MakeRequestClientSendCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockGitlabAccess_MakeRequestClientSendCall) Do(f func(*grpctool.HttpRequest) error) *MockGitlabAccess_MakeRequestClientSendCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitlabAccess_MakeRequestClientSendCall) DoAndReturn(f func(*grpctool.HttpRequest) error) *MockGitlabAccess_MakeRequestClientSendCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SendMsg indicates an expected call of SendMsg.
func (mr *MockGitlabAccess_MakeRequestClientMockRecorder) SendMsg(arg0 any) *MockGitlabAccess_MakeRequestClientSendMsgCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockGitlabAccess_MakeRequestClient)(nil).SendMsg), arg0)
	return &MockGitlabAccess_MakeRequestClientSendMsgCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockGitlabAccess_MakeRequestClientSendMsgCall) Do(f func(any) error) *MockGitlabAccess_MakeRequestClientSendMsgCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitlabAccess_MakeRequestClientSendMsgCall) DoAndReturn(f func(any) error) *MockGitlabAccess_MakeRequestClientSendMsgCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Trailer mocks base method.
func (m *MockGitlabAccess_MakeRequestClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockGitlabAccess_MakeRequestClientMockRecorder) Trailer() *MockGitlabAccess_MakeRequestClientTrailerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockGitlabAccess_MakeRequestClient)(nil).Trailer))
	return &MockGitlabAccess_MakeRequestClientTrailerCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockGitlabAccess_MakeRequestClientTrailerCall) Return(arg0 metadata.MD) *MockGitlabAccess_MakeRequestClientTrailerCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGitlabAccess_MakeRequestClientTrailerCall) Do(f func() metadata.MD) *MockGitlabAccess_MakeRequestClientTrailerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitlabAccess_MakeRequestClientTrailerCall) DoAndReturn(f func() metadata.MD) *MockGitlabAccess_MakeRequestClientTrailerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}