// Code generated by MockGen. DO NOT EDIT.
// Source: gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/tunnel/tunserver (interfaces: DataCallback,GatewayFinder)
//
// Generated by this command:
//
//	mockgen -typed -destination tunnel.go -package mock_tunnel_tunserver gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/tunnel/tunserver DataCallback,GatewayFinder
//

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

import (
	context "context"
	reflect "reflect"

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

// MockDataCallback is a mock of DataCallback interface.
type MockDataCallback struct {
	ctrl     *gomock.Controller
	recorder *MockDataCallbackMockRecorder
	isgomock struct{}
}

// MockDataCallbackMockRecorder is the mock recorder for MockDataCallback.
type MockDataCallbackMockRecorder struct {
	mock *MockDataCallback
}

// NewMockDataCallback creates a new mock instance.
func NewMockDataCallback(ctrl *gomock.Controller) *MockDataCallback {
	mock := &MockDataCallback{ctrl: ctrl}
	mock.recorder = &MockDataCallbackMockRecorder{mock}
	return mock
}

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

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

// Error indicates an expected call of Error.
func (mr *MockDataCallbackMockRecorder) Error(arg0 any) *MockDataCallbackErrorCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockDataCallback)(nil).Error), arg0)
	return &MockDataCallbackErrorCall{Call: call}
}

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

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

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

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

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

// Header indicates an expected call of Header.
func (mr *MockDataCallbackMockRecorder) Header(arg0 any) *MockDataCallbackHeaderCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockDataCallback)(nil).Header), arg0)
	return &MockDataCallbackHeaderCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockDataCallbackHeaderCall) Do(f func([]*rpc.MetadataKV) error) *MockDataCallbackHeaderCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockDataCallbackHeaderCall) DoAndReturn(f func([]*rpc.MetadataKV) error) *MockDataCallbackHeaderCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Message indicates an expected call of Message.
func (mr *MockDataCallbackMockRecorder) Message(arg0 any) *MockDataCallbackMessageCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Message", reflect.TypeOf((*MockDataCallback)(nil).Message), arg0)
	return &MockDataCallbackMessageCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockDataCallbackMessageCall) Do(f func([]byte) error) *MockDataCallbackMessageCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockDataCallbackMessageCall) DoAndReturn(f func([]byte) error) *MockDataCallbackMessageCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Trailer indicates an expected call of Trailer.
func (mr *MockDataCallbackMockRecorder) Trailer(arg0 any) *MockDataCallbackTrailerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockDataCallback)(nil).Trailer), arg0)
	return &MockDataCallbackTrailerCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockDataCallbackTrailerCall) Do(f func([]*rpc.MetadataKV) error) *MockDataCallbackTrailerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockDataCallbackTrailerCall) DoAndReturn(f func([]*rpc.MetadataKV) error) *MockDataCallbackTrailerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockGatewayFinder is a mock of GatewayFinder interface.
type MockGatewayFinder[T tunserver.Target] struct {
	ctrl     *gomock.Controller
	recorder *MockGatewayFinderMockRecorder[T]
	isgomock struct{}
}

// MockGatewayFinderMockRecorder is the mock recorder for MockGatewayFinder.
type MockGatewayFinderMockRecorder[T tunserver.Target] struct {
	mock *MockGatewayFinder[T]
}

// NewMockGatewayFinder creates a new mock instance.
func NewMockGatewayFinder[T tunserver.Target](ctrl *gomock.Controller) *MockGatewayFinder[T] {
	mock := &MockGatewayFinder[T]{ctrl: ctrl}
	mock.recorder = &MockGatewayFinderMockRecorder[T]{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockGatewayFinder[T]) EXPECT() *MockGatewayFinderMockRecorder[T] {
	return m.recorder
}

// Find mocks base method.
func (m *MockGatewayFinder[T]) Find(ctx context.Context) (tunserver.ReadyGateway[T], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Find", ctx)
	ret0, _ := ret[0].(tunserver.ReadyGateway[T])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find.
func (mr *MockGatewayFinderMockRecorder[T]) Find(ctx any) *MockGatewayFinderFindCall[T] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockGatewayFinder[T])(nil).Find), ctx)
	return &MockGatewayFinderFindCall[T]{Call: call}
}

// MockGatewayFinderFindCall wrap *gomock.Call
type MockGatewayFinderFindCall[T tunserver.Target] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockGatewayFinderFindCall[T]) Return(arg0 tunserver.ReadyGateway[T], arg1 error) *MockGatewayFinderFindCall[T] {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockGatewayFinderFindCall[T]) Do(f func(context.Context) (tunserver.ReadyGateway[T], error)) *MockGatewayFinderFindCall[T] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockGatewayFinderFindCall[T]) DoAndReturn(f func(context.Context) (tunserver.ReadyGateway[T], error)) *MockGatewayFinderFindCall[T] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
