// Code generated by MockGen. DO NOT EDIT.
// Source: ../../../tunnel/rpc/rpc_grpc.pb.go
//
// Generated by this command:
//
//	mockgen -typed -source ../../../tunnel/rpc/rpc_grpc.pb.go -destination rpc.go -package mock_tunnel_rpc gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/tunnel/rpc ReverseTunnel_ConnectServer,ReverseTunnel_ConnectClient,ReverseTunnelClient
//

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

import (
	context "context"
	reflect "reflect"

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

// MockReverseTunnelClient is a mock of ReverseTunnelClient interface.
type MockReverseTunnelClient struct {
	ctrl     *gomock.Controller
	recorder *MockReverseTunnelClientMockRecorder
	isgomock struct{}
}

// MockReverseTunnelClientMockRecorder is the mock recorder for MockReverseTunnelClient.
type MockReverseTunnelClientMockRecorder struct {
	mock *MockReverseTunnelClient
}

// NewMockReverseTunnelClient creates a new mock instance.
func NewMockReverseTunnelClient(ctrl *gomock.Controller) *MockReverseTunnelClient {
	mock := &MockReverseTunnelClient{ctrl: ctrl}
	mock.recorder = &MockReverseTunnelClientMockRecorder{mock}
	return mock
}

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

// Connect mocks base method.
func (m *MockReverseTunnelClient) Connect(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[rpc.ConnectRequest, rpc.ConnectResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Connect", varargs...)
	ret0, _ := ret[0].(grpc.BidiStreamingClient[rpc.ConnectRequest, rpc.ConnectResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Connect indicates an expected call of Connect.
func (mr *MockReverseTunnelClientMockRecorder) Connect(ctx any, opts ...any) *MockReverseTunnelClientConnectCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockReverseTunnelClient)(nil).Connect), varargs...)
	return &MockReverseTunnelClientConnectCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockReverseTunnelClientConnectCall) Return(arg0 grpc.BidiStreamingClient[rpc.ConnectRequest, rpc.ConnectResponse], arg1 error) *MockReverseTunnelClientConnectCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockReverseTunnelClientConnectCall) Do(f func(context.Context, ...grpc.CallOption) (grpc.BidiStreamingClient[rpc.ConnectRequest, rpc.ConnectResponse], error)) *MockReverseTunnelClientConnectCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockReverseTunnelClientConnectCall) DoAndReturn(f func(context.Context, ...grpc.CallOption) (grpc.BidiStreamingClient[rpc.ConnectRequest, rpc.ConnectResponse], error)) *MockReverseTunnelClientConnectCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockReverseTunnelServer is a mock of ReverseTunnelServer interface.
type MockReverseTunnelServer struct {
	ctrl     *gomock.Controller
	recorder *MockReverseTunnelServerMockRecorder
	isgomock struct{}
}

// MockReverseTunnelServerMockRecorder is the mock recorder for MockReverseTunnelServer.
type MockReverseTunnelServerMockRecorder struct {
	mock *MockReverseTunnelServer
}

// NewMockReverseTunnelServer creates a new mock instance.
func NewMockReverseTunnelServer(ctrl *gomock.Controller) *MockReverseTunnelServer {
	mock := &MockReverseTunnelServer{ctrl: ctrl}
	mock.recorder = &MockReverseTunnelServerMockRecorder{mock}
	return mock
}

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

// Connect mocks base method.
func (m *MockReverseTunnelServer) Connect(arg0 grpc.BidiStreamingServer[rpc.ConnectRequest, rpc.ConnectResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Connect", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Connect indicates an expected call of Connect.
func (mr *MockReverseTunnelServerMockRecorder) Connect(arg0 any) *MockReverseTunnelServerConnectCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockReverseTunnelServer)(nil).Connect), arg0)
	return &MockReverseTunnelServerConnectCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockReverseTunnelServerConnectCall) Do(f func(grpc.BidiStreamingServer[rpc.ConnectRequest, rpc.ConnectResponse]) error) *MockReverseTunnelServerConnectCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockReverseTunnelServerConnectCall) DoAndReturn(f func(grpc.BidiStreamingServer[rpc.ConnectRequest, rpc.ConnectResponse]) error) *MockReverseTunnelServerConnectCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// mustEmbedUnimplementedReverseTunnelServer indicates an expected call of mustEmbedUnimplementedReverseTunnelServer.
func (mr *MockReverseTunnelServerMockRecorder) mustEmbedUnimplementedReverseTunnelServer() *MockReverseTunnelServermustEmbedUnimplementedReverseTunnelServerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedReverseTunnelServer", reflect.TypeOf((*MockReverseTunnelServer)(nil).mustEmbedUnimplementedReverseTunnelServer))
	return &MockReverseTunnelServermustEmbedUnimplementedReverseTunnelServerCall{Call: call}
}

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

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

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

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

// MockUnsafeReverseTunnelServer is a mock of UnsafeReverseTunnelServer interface.
type MockUnsafeReverseTunnelServer struct {
	ctrl     *gomock.Controller
	recorder *MockUnsafeReverseTunnelServerMockRecorder
	isgomock struct{}
}

// MockUnsafeReverseTunnelServerMockRecorder is the mock recorder for MockUnsafeReverseTunnelServer.
type MockUnsafeReverseTunnelServerMockRecorder struct {
	mock *MockUnsafeReverseTunnelServer
}

// NewMockUnsafeReverseTunnelServer creates a new mock instance.
func NewMockUnsafeReverseTunnelServer(ctrl *gomock.Controller) *MockUnsafeReverseTunnelServer {
	mock := &MockUnsafeReverseTunnelServer{ctrl: ctrl}
	mock.recorder = &MockUnsafeReverseTunnelServerMockRecorder{mock}
	return mock
}

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

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

// mustEmbedUnimplementedReverseTunnelServer indicates an expected call of mustEmbedUnimplementedReverseTunnelServer.
func (mr *MockUnsafeReverseTunnelServerMockRecorder) mustEmbedUnimplementedReverseTunnelServer() *MockUnsafeReverseTunnelServermustEmbedUnimplementedReverseTunnelServerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedReverseTunnelServer", reflect.TypeOf((*MockUnsafeReverseTunnelServer)(nil).mustEmbedUnimplementedReverseTunnelServer))
	return &MockUnsafeReverseTunnelServermustEmbedUnimplementedReverseTunnelServerCall{Call: call}
}

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

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

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

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