// Code generated by MockGen. DO NOT EDIT.
// Source: gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/tool/grpctool (interfaces: InboundGRPCToOutboundHTTPStream,PoolConn,PoolInterface,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,PoolConn,PoolInterface,ServerErrorReporter
//

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

import (
	context "context"
	reflect "reflect"
	time "time"

	grpctool "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/tool/grpctool"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
	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
}

// MockPoolConn is a mock of PoolConn interface.
type MockPoolConn struct {
	ctrl     *gomock.Controller
	recorder *MockPoolConnMockRecorder
	isgomock struct{}
}

// MockPoolConnMockRecorder is the mock recorder for MockPoolConn.
type MockPoolConnMockRecorder struct {
	mock *MockPoolConn
}

// NewMockPoolConn creates a new mock instance.
func NewMockPoolConn(ctrl *gomock.Controller) *MockPoolConn {
	mock := &MockPoolConn{ctrl: ctrl}
	mock.recorder = &MockPoolConnMockRecorder{mock}
	return mock
}

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

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

// Done indicates an expected call of Done.
func (mr *MockPoolConnMockRecorder) Done() *MockPoolConnDoneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Done", reflect.TypeOf((*MockPoolConn)(nil).Done))
	return &MockPoolConnDoneCall{Call: call}
}

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

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

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

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

// Invoke mocks base method.
func (m *MockPoolConn) Invoke(ctx context.Context, method string, args, reply any, opts ...grpc.CallOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, method, args, reply}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Invoke", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Invoke indicates an expected call of Invoke.
func (mr *MockPoolConnMockRecorder) Invoke(ctx, method, args, reply any, opts ...any) *MockPoolConnInvokeCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, method, args, reply}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Invoke", reflect.TypeOf((*MockPoolConn)(nil).Invoke), varargs...)
	return &MockPoolConnInvokeCall{Call: call}
}

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

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

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

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

// NewStream mocks base method.
func (m *MockPoolConn) NewStream(ctx context.Context, desc *grpc.StreamDesc, method string, opts ...grpc.CallOption) (grpc.ClientStream, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, desc, method}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "NewStream", varargs...)
	ret0, _ := ret[0].(grpc.ClientStream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewStream indicates an expected call of NewStream.
func (mr *MockPoolConnMockRecorder) NewStream(ctx, desc, method any, opts ...any) *MockPoolConnNewStreamCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, desc, method}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewStream", reflect.TypeOf((*MockPoolConn)(nil).NewStream), varargs...)
	return &MockPoolConnNewStreamCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockPoolConnNewStreamCall) Return(arg0 grpc.ClientStream, arg1 error) *MockPoolConnNewStreamCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPoolConnNewStreamCall) Do(f func(context.Context, *grpc.StreamDesc, string, ...grpc.CallOption) (grpc.ClientStream, error)) *MockPoolConnNewStreamCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPoolConnNewStreamCall) DoAndReturn(f func(context.Context, *grpc.StreamDesc, string, ...grpc.CallOption) (grpc.ClientStream, error)) *MockPoolConnNewStreamCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockPoolInterface is a mock of PoolInterface interface.
type MockPoolInterface[T grpctool.Target] struct {
	ctrl     *gomock.Controller
	recorder *MockPoolInterfaceMockRecorder[T]
	isgomock struct{}
}

// MockPoolInterfaceMockRecorder is the mock recorder for MockPoolInterface.
type MockPoolInterfaceMockRecorder[T grpctool.Target] struct {
	mock *MockPoolInterface[T]
}

// NewMockPoolInterface creates a new mock instance.
func NewMockPoolInterface[T grpctool.Target](ctrl *gomock.Controller) *MockPoolInterface[T] {
	mock := &MockPoolInterface[T]{ctrl: ctrl}
	mock.recorder = &MockPoolInterfaceMockRecorder[T]{mock}
	return mock
}

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

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

// Dial indicates an expected call of Dial.
func (mr *MockPoolInterfaceMockRecorder[T]) Dial(target any) *MockPoolInterfaceDialCall[T] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dial", reflect.TypeOf((*MockPoolInterface[T])(nil).Dial), target)
	return &MockPoolInterfaceDialCall[T]{Call: call}
}

// MockPoolInterfaceDialCall wrap *gomock.Call
type MockPoolInterfaceDialCall[T grpctool.Target] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPoolInterfaceDialCall[T]) Return(arg0 grpctool.PoolConn, arg1 error) *MockPoolInterfaceDialCall[T] {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPoolInterfaceDialCall[T]) Do(f func(T) (grpctool.PoolConn, error)) *MockPoolInterfaceDialCall[T] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPoolInterfaceDialCall[T]) DoAndReturn(f func(T) (grpctool.PoolConn, error)) *MockPoolInterfaceDialCall[T] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Shutdown mocks base method.
func (m *MockPoolInterface[T]) Shutdown(deadline time.Duration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Shutdown", deadline)
}

// Shutdown indicates an expected call of Shutdown.
func (mr *MockPoolInterfaceMockRecorder[T]) Shutdown(deadline any) *MockPoolInterfaceShutdownCall[T] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockPoolInterface[T])(nil).Shutdown), deadline)
	return &MockPoolInterfaceShutdownCall[T]{Call: call}
}

// MockPoolInterfaceShutdownCall wrap *gomock.Call
type MockPoolInterfaceShutdownCall[T grpctool.Target] struct {
	*gomock.Call
}

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

// Do rewrite *gomock.Call.Do
func (c *MockPoolInterfaceShutdownCall[T]) Do(f func(time.Duration)) *MockPoolInterfaceShutdownCall[T] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPoolInterfaceShutdownCall[T]) DoAndReturn(f func(time.Duration)) *MockPoolInterfaceShutdownCall[T] {
	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
}
