// Code generated by MockGen. DO NOT EDIT.
// Source: ../../../module/gitlab_access/rpc/rpc_grpc.pb.go
//
// Generated by this command:
//
//	mockgen -typed -source ../../../module/gitlab_access/rpc/rpc_grpc.pb.go -destination gitlab_access.go -package mock_gitlab_access
//

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

import (
	context "context"
	reflect "reflect"

	grpctool "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/tool/grpctool"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
)

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

// 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(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[grpctool.HttpRequest, grpctool.HttpResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MakeRequest", varargs...)
	ret0, _ := ret[0].(grpc.BidiStreamingClient[grpctool.HttpRequest, grpctool.HttpResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MakeRequest indicates an expected call of MakeRequest.
func (mr *MockGitlabAccessClientMockRecorder) MakeRequest(ctx any, opts ...any) *MockGitlabAccessClientMakeRequestCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, opts...)
	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 grpc.BidiStreamingClient[grpctool.HttpRequest, grpctool.HttpResponse], 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) (grpc.BidiStreamingClient[grpctool.HttpRequest, grpctool.HttpResponse], 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) (grpc.BidiStreamingClient[grpctool.HttpRequest, grpctool.HttpResponse], error)) *MockGitlabAccessClientMakeRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGitlabAccessServer is a mock of GitlabAccessServer interface.
type MockGitlabAccessServer struct {
	ctrl     *gomock.Controller
	recorder *MockGitlabAccessServerMockRecorder
	isgomock struct{}
}

// MockGitlabAccessServerMockRecorder is the mock recorder for MockGitlabAccessServer.
type MockGitlabAccessServerMockRecorder struct {
	mock *MockGitlabAccessServer
}

// NewMockGitlabAccessServer creates a new mock instance.
func NewMockGitlabAccessServer(ctrl *gomock.Controller) *MockGitlabAccessServer {
	mock := &MockGitlabAccessServer{ctrl: ctrl}
	mock.recorder = &MockGitlabAccessServerMockRecorder{mock}
	return mock
}

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

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

// MakeRequest indicates an expected call of MakeRequest.
func (mr *MockGitlabAccessServerMockRecorder) MakeRequest(arg0 any) *MockGitlabAccessServerMakeRequestCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeRequest", reflect.TypeOf((*MockGitlabAccessServer)(nil).MakeRequest), arg0)
	return &MockGitlabAccessServerMakeRequestCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockGitlabAccessServerMakeRequestCall) Do(f func(grpc.BidiStreamingServer[grpctool.HttpRequest, grpctool.HttpResponse]) error) *MockGitlabAccessServerMakeRequestCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGitlabAccessServerMakeRequestCall) DoAndReturn(f func(grpc.BidiStreamingServer[grpctool.HttpRequest, grpctool.HttpResponse]) error) *MockGitlabAccessServerMakeRequestCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// mustEmbedUnimplementedGitlabAccessServer mocks base method.
func (m *MockGitlabAccessServer) mustEmbedUnimplementedGitlabAccessServer() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "mustEmbedUnimplementedGitlabAccessServer")
}

// mustEmbedUnimplementedGitlabAccessServer indicates an expected call of mustEmbedUnimplementedGitlabAccessServer.
func (mr *MockGitlabAccessServerMockRecorder) mustEmbedUnimplementedGitlabAccessServer() *MockGitlabAccessServermustEmbedUnimplementedGitlabAccessServerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedGitlabAccessServer", reflect.TypeOf((*MockGitlabAccessServer)(nil).mustEmbedUnimplementedGitlabAccessServer))
	return &MockGitlabAccessServermustEmbedUnimplementedGitlabAccessServerCall{Call: call}
}

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

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

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

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

// MockUnsafeGitlabAccessServer is a mock of UnsafeGitlabAccessServer interface.
type MockUnsafeGitlabAccessServer struct {
	ctrl     *gomock.Controller
	recorder *MockUnsafeGitlabAccessServerMockRecorder
	isgomock struct{}
}

// MockUnsafeGitlabAccessServerMockRecorder is the mock recorder for MockUnsafeGitlabAccessServer.
type MockUnsafeGitlabAccessServerMockRecorder struct {
	mock *MockUnsafeGitlabAccessServer
}

// NewMockUnsafeGitlabAccessServer creates a new mock instance.
func NewMockUnsafeGitlabAccessServer(ctrl *gomock.Controller) *MockUnsafeGitlabAccessServer {
	mock := &MockUnsafeGitlabAccessServer{ctrl: ctrl}
	mock.recorder = &MockUnsafeGitlabAccessServerMockRecorder{mock}
	return mock
}

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

// mustEmbedUnimplementedGitlabAccessServer mocks base method.
func (m *MockUnsafeGitlabAccessServer) mustEmbedUnimplementedGitlabAccessServer() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "mustEmbedUnimplementedGitlabAccessServer")
}

// mustEmbedUnimplementedGitlabAccessServer indicates an expected call of mustEmbedUnimplementedGitlabAccessServer.
func (mr *MockUnsafeGitlabAccessServerMockRecorder) mustEmbedUnimplementedGitlabAccessServer() *MockUnsafeGitlabAccessServermustEmbedUnimplementedGitlabAccessServerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedGitlabAccessServer", reflect.TypeOf((*MockUnsafeGitlabAccessServer)(nil).mustEmbedUnimplementedGitlabAccessServer))
	return &MockUnsafeGitlabAccessServermustEmbedUnimplementedGitlabAccessServerCall{Call: call}
}

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

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

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

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