// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/grpc/flow_handler_grpc.pb.go
//
// Generated by this command:
//
//	mockgen -package=mock_flow_handler -source=pkg/grpc/flow_handler_grpc.pb.go -destination pkg/collector/mock/mock_flow_handler.go -mock_names FlowHandlerClient=FlowHandlerClient,FlowHandlerServer=FlowHandlerServer,FlowHandler_SubmitClient=FlowHandler_SubmitClient
//

// Package mock_flow_handler is a generated GoMock package.
package mock_collector

import (
	context "context"
	reflect "reflect"

	grpc "github.com/ClickHouse/kubenetmon/pkg/grpc"
	gomock "go.uber.org/mock/gomock"
	grpc0 "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"
)

// FlowHandlerClient is a mock of FlowHandlerClient interface.
type FlowHandlerClient struct {
	ctrl     *gomock.Controller
	recorder *FlowHandlerClientMockRecorder
}

// FlowHandlerClientMockRecorder is the mock recorder for FlowHandlerClient.
type FlowHandlerClientMockRecorder struct {
	mock *FlowHandlerClient
}

// NewFlowHandlerClient creates a new mock instance.
func NewFlowHandlerClient(ctrl *gomock.Controller) *FlowHandlerClient {
	mock := &FlowHandlerClient{ctrl: ctrl}
	mock.recorder = &FlowHandlerClientMockRecorder{mock}
	return mock
}

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

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

// Submit indicates an expected call of Submit.
func (mr *FlowHandlerClientMockRecorder) Submit(ctx any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Submit", reflect.TypeOf((*FlowHandlerClient)(nil).Submit), varargs...)
}

// FlowHandler_SubmitClient is a mock of FlowHandler_SubmitClient interface.
type FlowHandler_SubmitClient struct {
	ctrl     *gomock.Controller
	recorder *FlowHandler_SubmitClientMockRecorder
}

// FlowHandler_SubmitClientMockRecorder is the mock recorder for FlowHandler_SubmitClient.
type FlowHandler_SubmitClientMockRecorder struct {
	mock *FlowHandler_SubmitClient
}

// NewFlowHandler_SubmitClient creates a new mock instance.
func NewFlowHandler_SubmitClient(ctrl *gomock.Controller) *FlowHandler_SubmitClient {
	mock := &FlowHandler_SubmitClient{ctrl: ctrl}
	mock.recorder = &FlowHandler_SubmitClientMockRecorder{mock}
	return mock
}

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

// CloseAndRecv mocks base method.
func (m *FlowHandler_SubmitClient) CloseAndRecv() (*grpc.ObservationSummary, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseAndRecv")
	ret0, _ := ret[0].(*grpc.ObservationSummary)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CloseAndRecv indicates an expected call of CloseAndRecv.
func (mr *FlowHandler_SubmitClientMockRecorder) CloseAndRecv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseAndRecv", reflect.TypeOf((*FlowHandler_SubmitClient)(nil).CloseAndRecv))
}

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

// CloseSend indicates an expected call of CloseSend.
func (mr *FlowHandler_SubmitClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*FlowHandler_SubmitClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *FlowHandler_SubmitClient) 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 *FlowHandler_SubmitClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*FlowHandler_SubmitClient)(nil).Context))
}

// Header mocks base method.
func (m *FlowHandler_SubmitClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *FlowHandler_SubmitClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*FlowHandler_SubmitClient)(nil).Header))
}

// RecvMsg mocks base method.
func (m_2 *FlowHandler_SubmitClient) 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 *FlowHandler_SubmitClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*FlowHandler_SubmitClient)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *FlowHandler_SubmitClient) Send(arg0 *grpc.Observation) 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 *FlowHandler_SubmitClientMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*FlowHandler_SubmitClient)(nil).Send), arg0)
}

// SendMsg mocks base method.
func (m_2 *FlowHandler_SubmitClient) 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 *FlowHandler_SubmitClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*FlowHandler_SubmitClient)(nil).SendMsg), m)
}

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

// Trailer indicates an expected call of Trailer.
func (mr *FlowHandler_SubmitClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*FlowHandler_SubmitClient)(nil).Trailer))
}

// FlowHandlerServer is a mock of FlowHandlerServer interface.
type FlowHandlerServer struct {
	ctrl     *gomock.Controller
	recorder *FlowHandlerServerMockRecorder
}

// FlowHandlerServerMockRecorder is the mock recorder for FlowHandlerServer.
type FlowHandlerServerMockRecorder struct {
	mock *FlowHandlerServer
}

// NewFlowHandlerServer creates a new mock instance.
func NewFlowHandlerServer(ctrl *gomock.Controller) *FlowHandlerServer {
	mock := &FlowHandlerServer{ctrl: ctrl}
	mock.recorder = &FlowHandlerServerMockRecorder{mock}
	return mock
}

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

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

// Submit indicates an expected call of Submit.
func (mr *FlowHandlerServerMockRecorder) Submit(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Submit", reflect.TypeOf((*FlowHandlerServer)(nil).Submit), arg0)
}

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

// mustEmbedUnimplementedFlowHandlerServer indicates an expected call of mustEmbedUnimplementedFlowHandlerServer.
func (mr *FlowHandlerServerMockRecorder) mustEmbedUnimplementedFlowHandlerServer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedFlowHandlerServer", reflect.TypeOf((*FlowHandlerServer)(nil).mustEmbedUnimplementedFlowHandlerServer))
}

// MockUnsafeFlowHandlerServer is a mock of UnsafeFlowHandlerServer interface.
type MockUnsafeFlowHandlerServer struct {
	ctrl     *gomock.Controller
	recorder *MockUnsafeFlowHandlerServerMockRecorder
}

// MockUnsafeFlowHandlerServerMockRecorder is the mock recorder for MockUnsafeFlowHandlerServer.
type MockUnsafeFlowHandlerServerMockRecorder struct {
	mock *MockUnsafeFlowHandlerServer
}

// NewMockUnsafeFlowHandlerServer creates a new mock instance.
func NewMockUnsafeFlowHandlerServer(ctrl *gomock.Controller) *MockUnsafeFlowHandlerServer {
	mock := &MockUnsafeFlowHandlerServer{ctrl: ctrl}
	mock.recorder = &MockUnsafeFlowHandlerServerMockRecorder{mock}
	return mock
}

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

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

// mustEmbedUnimplementedFlowHandlerServer indicates an expected call of mustEmbedUnimplementedFlowHandlerServer.
func (mr *MockUnsafeFlowHandlerServerMockRecorder) mustEmbedUnimplementedFlowHandlerServer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedFlowHandlerServer", reflect.TypeOf((*MockUnsafeFlowHandlerServer)(nil).mustEmbedUnimplementedFlowHandlerServer))
}

// MockFlowHandler_SubmitServer is a mock of FlowHandler_SubmitServer interface.
type MockFlowHandler_SubmitServer struct {
	ctrl     *gomock.Controller
	recorder *MockFlowHandler_SubmitServerMockRecorder
}

// MockFlowHandler_SubmitServerMockRecorder is the mock recorder for MockFlowHandler_SubmitServer.
type MockFlowHandler_SubmitServerMockRecorder struct {
	mock *MockFlowHandler_SubmitServer
}

// NewMockFlowHandler_SubmitServer creates a new mock instance.
func NewMockFlowHandler_SubmitServer(ctrl *gomock.Controller) *MockFlowHandler_SubmitServer {
	mock := &MockFlowHandler_SubmitServer{ctrl: ctrl}
	mock.recorder = &MockFlowHandler_SubmitServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockFlowHandler_SubmitServer) 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 *MockFlowHandler_SubmitServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockFlowHandler_SubmitServer)(nil).Context))
}

// Recv mocks base method.
func (m *MockFlowHandler_SubmitServer) Recv() (*grpc.Observation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*grpc.Observation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockFlowHandler_SubmitServerMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockFlowHandler_SubmitServer)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockFlowHandler_SubmitServer) 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 *MockFlowHandler_SubmitServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockFlowHandler_SubmitServer)(nil).RecvMsg), m)
}

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

// SendAndClose indicates an expected call of SendAndClose.
func (mr *MockFlowHandler_SubmitServerMockRecorder) SendAndClose(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAndClose", reflect.TypeOf((*MockFlowHandler_SubmitServer)(nil).SendAndClose), arg0)
}

// SendHeader mocks base method.
func (m *MockFlowHandler_SubmitServer) 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 *MockFlowHandler_SubmitServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockFlowHandler_SubmitServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockFlowHandler_SubmitServer) 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 *MockFlowHandler_SubmitServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockFlowHandler_SubmitServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockFlowHandler_SubmitServer) 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 *MockFlowHandler_SubmitServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockFlowHandler_SubmitServer)(nil).SetHeader), arg0)
}

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

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockFlowHandler_SubmitServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockFlowHandler_SubmitServer)(nil).SetTrailer), arg0)
}
