// Code generated by MockGen. DO NOT EDIT.
// Source: gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/tool/grpctool (interfaces: InboundGRPCToOutboundHTTPStream,ServerErrorReporter)
//
// Generated by this command:
//
//	mockgen -typed -destination grpctool.go -package mock_rpc gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/tool/grpctool InboundGRPCToOutboundHTTPStream,ServerErrorReporter
//

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

import (
	context "context"
	reflect "reflect"

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

// MockInboundGRPCToOutboundHTTPStream is a mock of InboundGRPCToOutboundHTTPStream interface.
type MockInboundGRPCToOutboundHTTPStream[Res any] struct {
	ctrl     *gomock.Controller
	recorder *MockInboundGRPCToOutboundHTTPStreamMockRecorder[Res]
	isgomock struct{}
}

// MockInboundGRPCToOutboundHTTPStreamMockRecorder is the mock recorder for MockInboundGRPCToOutboundHTTPStream.
type MockInboundGRPCToOutboundHTTPStreamMockRecorder[Res any] struct {
	mock *MockInboundGRPCToOutboundHTTPStream[Res]
}

// NewMockInboundGRPCToOutboundHTTPStream creates a new mock instance.
func NewMockInboundGRPCToOutboundHTTPStream[Res any](ctrl *gomock.Controller) *MockInboundGRPCToOutboundHTTPStream[Res] {
	mock := &MockInboundGRPCToOutboundHTTPStream[Res]{ctrl: ctrl}
	mock.recorder = &MockInboundGRPCToOutboundHTTPStreamMockRecorder[Res]{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockInboundGRPCToOutboundHTTPStream[Res]) 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 *MockInboundGRPCToOutboundHTTPStreamMockRecorder[Res]) Context() *MockInboundGRPCToOutboundHTTPStreamContextCall[Res] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockInboundGRPCToOutboundHTTPStream[Res])(nil).Context))
	return &MockInboundGRPCToOutboundHTTPStreamContextCall[Res]{Call: call}
}

// MockInboundGRPCToOutboundHTTPStreamContextCall wrap *gomock.Call
type MockInboundGRPCToOutboundHTTPStreamContextCall[Res any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockInboundGRPCToOutboundHTTPStreamContextCall[Res]) Return(arg0 context.Context) *MockInboundGRPCToOutboundHTTPStreamContextCall[Res] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockInboundGRPCToOutboundHTTPStreamContextCall[Res]) Do(f func() context.Context) *MockInboundGRPCToOutboundHTTPStreamContextCall[Res] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockInboundGRPCToOutboundHTTPStreamContextCall[Res]) DoAndReturn(f func() context.Context) *MockInboundGRPCToOutboundHTTPStreamContextCall[Res] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockInboundGRPCToOutboundHTTPStreamMockRecorder[Res]) RecvMsg(m any) *MockInboundGRPCToOutboundHTTPStreamRecvMsgCall[Res] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockInboundGRPCToOutboundHTTPStream[Res])(nil).RecvMsg), m)
	return &MockInboundGRPCToOutboundHTTPStreamRecvMsgCall[Res]{Call: call}
}

// MockInboundGRPCToOutboundHTTPStreamRecvMsgCall wrap *gomock.Call
type MockInboundGRPCToOutboundHTTPStreamRecvMsgCall[Res any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockInboundGRPCToOutboundHTTPStreamRecvMsgCall[Res]) Return(arg0 error) *MockInboundGRPCToOutboundHTTPStreamRecvMsgCall[Res] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockInboundGRPCToOutboundHTTPStreamRecvMsgCall[Res]) Do(f func(any) error) *MockInboundGRPCToOutboundHTTPStreamRecvMsgCall[Res] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockInboundGRPCToOutboundHTTPStreamRecvMsgCall[Res]) DoAndReturn(f func(any) error) *MockInboundGRPCToOutboundHTTPStreamRecvMsgCall[Res] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Send mocks base method.
func (m *MockInboundGRPCToOutboundHTTPStream[Res]) Send(arg0 *grpctool.HttpResponse) 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 *MockInboundGRPCToOutboundHTTPStreamMockRecorder[Res]) Send(arg0 any) *MockInboundGRPCToOutboundHTTPStreamSendCall[Res] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockInboundGRPCToOutboundHTTPStream[Res])(nil).Send), arg0)
	return &MockInboundGRPCToOutboundHTTPStreamSendCall[Res]{Call: call}
}

// MockInboundGRPCToOutboundHTTPStreamSendCall wrap *gomock.Call
type MockInboundGRPCToOutboundHTTPStreamSendCall[Res any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockInboundGRPCToOutboundHTTPStreamSendCall[Res]) Return(arg0 error) *MockInboundGRPCToOutboundHTTPStreamSendCall[Res] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockInboundGRPCToOutboundHTTPStreamSendCall[Res]) Do(f func(*grpctool.HttpResponse) error) *MockInboundGRPCToOutboundHTTPStreamSendCall[Res] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockInboundGRPCToOutboundHTTPStreamSendCall[Res]) DoAndReturn(f func(*grpctool.HttpResponse) error) *MockInboundGRPCToOutboundHTTPStreamSendCall[Res] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SendHeader indicates an expected call of SendHeader.
func (mr *MockInboundGRPCToOutboundHTTPStreamMockRecorder[Res]) SendHeader(arg0 any) *MockInboundGRPCToOutboundHTTPStreamSendHeaderCall[Res] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockInboundGRPCToOutboundHTTPStream[Res])(nil).SendHeader), arg0)
	return &MockInboundGRPCToOutboundHTTPStreamSendHeaderCall[Res]{Call: call}
}

// MockInboundGRPCToOutboundHTTPStreamSendHeaderCall wrap *gomock.Call
type MockInboundGRPCToOutboundHTTPStreamSendHeaderCall[Res any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockInboundGRPCToOutboundHTTPStreamSendHeaderCall[Res]) Return(arg0 error) *MockInboundGRPCToOutboundHTTPStreamSendHeaderCall[Res] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockInboundGRPCToOutboundHTTPStreamSendHeaderCall[Res]) Do(f func(metadata.MD) error) *MockInboundGRPCToOutboundHTTPStreamSendHeaderCall[Res] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockInboundGRPCToOutboundHTTPStreamSendHeaderCall[Res]) DoAndReturn(f func(metadata.MD) error) *MockInboundGRPCToOutboundHTTPStreamSendHeaderCall[Res] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SendMsg indicates an expected call of SendMsg.
func (mr *MockInboundGRPCToOutboundHTTPStreamMockRecorder[Res]) SendMsg(m any) *MockInboundGRPCToOutboundHTTPStreamSendMsgCall[Res] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockInboundGRPCToOutboundHTTPStream[Res])(nil).SendMsg), m)
	return &MockInboundGRPCToOutboundHTTPStreamSendMsgCall[Res]{Call: call}
}

// MockInboundGRPCToOutboundHTTPStreamSendMsgCall wrap *gomock.Call
type MockInboundGRPCToOutboundHTTPStreamSendMsgCall[Res any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockInboundGRPCToOutboundHTTPStreamSendMsgCall[Res]) Return(arg0 error) *MockInboundGRPCToOutboundHTTPStreamSendMsgCall[Res] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockInboundGRPCToOutboundHTTPStreamSendMsgCall[Res]) Do(f func(any) error) *MockInboundGRPCToOutboundHTTPStreamSendMsgCall[Res] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockInboundGRPCToOutboundHTTPStreamSendMsgCall[Res]) DoAndReturn(f func(any) error) *MockInboundGRPCToOutboundHTTPStreamSendMsgCall[Res] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetHeader indicates an expected call of SetHeader.
func (mr *MockInboundGRPCToOutboundHTTPStreamMockRecorder[Res]) SetHeader(arg0 any) *MockInboundGRPCToOutboundHTTPStreamSetHeaderCall[Res] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockInboundGRPCToOutboundHTTPStream[Res])(nil).SetHeader), arg0)
	return &MockInboundGRPCToOutboundHTTPStreamSetHeaderCall[Res]{Call: call}
}

// MockInboundGRPCToOutboundHTTPStreamSetHeaderCall wrap *gomock.Call
type MockInboundGRPCToOutboundHTTPStreamSetHeaderCall[Res any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockInboundGRPCToOutboundHTTPStreamSetHeaderCall[Res]) Return(arg0 error) *MockInboundGRPCToOutboundHTTPStreamSetHeaderCall[Res] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockInboundGRPCToOutboundHTTPStreamSetHeaderCall[Res]) Do(f func(metadata.MD) error) *MockInboundGRPCToOutboundHTTPStreamSetHeaderCall[Res] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockInboundGRPCToOutboundHTTPStreamSetHeaderCall[Res]) DoAndReturn(f func(metadata.MD) error) *MockInboundGRPCToOutboundHTTPStreamSetHeaderCall[Res] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetTrailer mocks base method.
func (m *MockInboundGRPCToOutboundHTTPStream[Res]) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockInboundGRPCToOutboundHTTPStreamMockRecorder[Res]) SetTrailer(arg0 any) *MockInboundGRPCToOutboundHTTPStreamSetTrailerCall[Res] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockInboundGRPCToOutboundHTTPStream[Res])(nil).SetTrailer), arg0)
	return &MockInboundGRPCToOutboundHTTPStreamSetTrailerCall[Res]{Call: call}
}

// MockInboundGRPCToOutboundHTTPStreamSetTrailerCall wrap *gomock.Call
type MockInboundGRPCToOutboundHTTPStreamSetTrailerCall[Res any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockInboundGRPCToOutboundHTTPStreamSetTrailerCall[Res]) Return() *MockInboundGRPCToOutboundHTTPStreamSetTrailerCall[Res] {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockInboundGRPCToOutboundHTTPStreamSetTrailerCall[Res]) Do(f func(metadata.MD)) *MockInboundGRPCToOutboundHTTPStreamSetTrailerCall[Res] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockInboundGRPCToOutboundHTTPStreamSetTrailerCall[Res]) DoAndReturn(f func(metadata.MD)) *MockInboundGRPCToOutboundHTTPStreamSetTrailerCall[Res] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockServerErrorReporter is a mock of ServerErrorReporter interface.
type MockServerErrorReporter struct {
	ctrl     *gomock.Controller
	recorder *MockServerErrorReporterMockRecorder
	isgomock struct{}
}

// MockServerErrorReporterMockRecorder is the mock recorder for MockServerErrorReporter.
type MockServerErrorReporterMockRecorder struct {
	mock *MockServerErrorReporter
}

// NewMockServerErrorReporter creates a new mock instance.
func NewMockServerErrorReporter(ctrl *gomock.Controller) *MockServerErrorReporter {
	mock := &MockServerErrorReporter{ctrl: ctrl}
	mock.recorder = &MockServerErrorReporterMockRecorder{mock}
	return mock
}

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

// Report mocks base method.
func (m *MockServerErrorReporter) Report(ctx context.Context, fullMethod string, err error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Report", ctx, fullMethod, err)
}

// Report indicates an expected call of Report.
func (mr *MockServerErrorReporterMockRecorder) Report(ctx, fullMethod, err any) *MockServerErrorReporterReportCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Report", reflect.TypeOf((*MockServerErrorReporter)(nil).Report), ctx, fullMethod, err)
	return &MockServerErrorReporterReportCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockServerErrorReporterReportCall) Do(f func(context.Context, string, error)) *MockServerErrorReporterReportCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockServerErrorReporterReportCall) DoAndReturn(f func(context.Context, string, error)) *MockServerErrorReporterReportCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
