// Code generated by MockGen. DO NOT EDIT.
// Source: gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v16/internal/tunnel/tunserver (interfaces: DataCallback,Tunnel,FindHandle,PollingGatewayURLQuerier,RouterPlugin)
//
// Generated by this command:
//
//	mockgen -typed -self_package gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v16/internal/tunnel/tunserver -destination mock_for_test.go -package tunserver gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v16/internal/tunnel/tunserver DataCallback,Tunnel,FindHandle,PollingGatewayURLQuerier,RouterPlugin
//

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

import (
	context "context"
	reflect "reflect"

	modshared "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v16/internal/module/modshared"
	prototool "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v16/internal/tool/prototool"
	gomock "go.uber.org/mock/gomock"
	zap "go.uber.org/zap"
	status "google.golang.org/genproto/googleapis/rpc/status"
	grpc "google.golang.org/grpc"
)

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

// 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 map[string]*prototool.Values) 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(map[string]*prototool.Values) error) *MockDataCallbackHeaderCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockDataCallbackHeaderCall) DoAndReturn(f func(map[string]*prototool.Values) 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 map[string]*prototool.Values) 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(map[string]*prototool.Values) error) *MockDataCallbackTrailerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockDataCallbackTrailerCall) DoAndReturn(f func(map[string]*prototool.Values) error) *MockDataCallbackTrailerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockTunnel is a mock of Tunnel interface.
type MockTunnel struct {
	ctrl     *gomock.Controller
	recorder *MockTunnelMockRecorder
}

// MockTunnelMockRecorder is the mock recorder for MockTunnel.
type MockTunnelMockRecorder struct {
	mock *MockTunnel
}

// NewMockTunnel creates a new mock instance.
func NewMockTunnel(ctrl *gomock.Controller) *MockTunnel {
	mock := &MockTunnel{ctrl: ctrl}
	mock.recorder = &MockTunnelMockRecorder{mock}
	return mock
}

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

// Done mocks base method.
func (m *MockTunnel) Done(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Done", arg0)
}

// Done indicates an expected call of Done.
func (mr *MockTunnelMockRecorder) Done(arg0 any) *MockTunnelDoneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Done", reflect.TypeOf((*MockTunnel)(nil).Done), arg0)
	return &MockTunnelDoneCall{Call: call}
}

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

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

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

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

// ForwardStream mocks base method.
func (m *MockTunnel) ForwardStream(arg0 *zap.Logger, arg1 modshared.RPCAPI, arg2 grpc.ServerStream, arg3 DataCallback) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForwardStream", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// ForwardStream indicates an expected call of ForwardStream.
func (mr *MockTunnelMockRecorder) ForwardStream(arg0, arg1, arg2, arg3 any) *MockTunnelForwardStreamCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForwardStream", reflect.TypeOf((*MockTunnel)(nil).ForwardStream), arg0, arg1, arg2, arg3)
	return &MockTunnelForwardStreamCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockTunnelForwardStreamCall) Do(f func(*zap.Logger, modshared.RPCAPI, grpc.ServerStream, DataCallback) error) *MockTunnelForwardStreamCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTunnelForwardStreamCall) DoAndReturn(f func(*zap.Logger, modshared.RPCAPI, grpc.ServerStream, DataCallback) error) *MockTunnelForwardStreamCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockFindHandle is a mock of FindHandle interface.
type MockFindHandle struct {
	ctrl     *gomock.Controller
	recorder *MockFindHandleMockRecorder
}

// MockFindHandleMockRecorder is the mock recorder for MockFindHandle.
type MockFindHandleMockRecorder struct {
	mock *MockFindHandle
}

// NewMockFindHandle creates a new mock instance.
func NewMockFindHandle(ctrl *gomock.Controller) *MockFindHandle {
	mock := &MockFindHandle{ctrl: ctrl}
	mock.recorder = &MockFindHandleMockRecorder{mock}
	return mock
}

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

// Done mocks base method.
func (m *MockFindHandle) Done(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Done", arg0)
}

// Done indicates an expected call of Done.
func (mr *MockFindHandleMockRecorder) Done(arg0 any) *MockFindHandleDoneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Done", reflect.TypeOf((*MockFindHandle)(nil).Done), arg0)
	return &MockFindHandleDoneCall{Call: call}
}

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

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

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

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

// Get mocks base method.
func (m *MockFindHandle) Get(arg0 context.Context) (Tunnel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", arg0)
	ret0, _ := ret[0].(Tunnel)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockFindHandleMockRecorder) Get(arg0 any) *MockFindHandleGetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockFindHandle)(nil).Get), arg0)
	return &MockFindHandleGetCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockFindHandleGetCall) Return(arg0 Tunnel, arg1 error) *MockFindHandleGetCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

// MockPollingGatewayURLQuerier is a mock of PollingGatewayURLQuerier interface.
type MockPollingGatewayURLQuerier struct {
	ctrl     *gomock.Controller
	recorder *MockPollingGatewayURLQuerierMockRecorder
}

// MockPollingGatewayURLQuerierMockRecorder is the mock recorder for MockPollingGatewayURLQuerier.
type MockPollingGatewayURLQuerierMockRecorder struct {
	mock *MockPollingGatewayURLQuerier
}

// NewMockPollingGatewayURLQuerier creates a new mock instance.
func NewMockPollingGatewayURLQuerier(ctrl *gomock.Controller) *MockPollingGatewayURLQuerier {
	mock := &MockPollingGatewayURLQuerier{ctrl: ctrl}
	mock.recorder = &MockPollingGatewayURLQuerierMockRecorder{mock}
	return mock
}

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

// CachedGatewayURLs mocks base method.
func (m *MockPollingGatewayURLQuerier) CachedGatewayURLs(arg0 int64) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CachedGatewayURLs", arg0)
	ret0, _ := ret[0].([]string)
	return ret0
}

// CachedGatewayURLs indicates an expected call of CachedGatewayURLs.
func (mr *MockPollingGatewayURLQuerierMockRecorder) CachedGatewayURLs(arg0 any) *MockPollingGatewayURLQuerierCachedGatewayURLsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CachedGatewayURLs", reflect.TypeOf((*MockPollingGatewayURLQuerier)(nil).CachedGatewayURLs), arg0)
	return &MockPollingGatewayURLQuerierCachedGatewayURLsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockPollingGatewayURLQuerierCachedGatewayURLsCall) Return(arg0 []string) *MockPollingGatewayURLQuerierCachedGatewayURLsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPollingGatewayURLQuerierCachedGatewayURLsCall) Do(f func(int64) []string) *MockPollingGatewayURLQuerierCachedGatewayURLsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPollingGatewayURLQuerierCachedGatewayURLsCall) DoAndReturn(f func(int64) []string) *MockPollingGatewayURLQuerierCachedGatewayURLsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PollGatewayURLs mocks base method.
func (m *MockPollingGatewayURLQuerier) PollGatewayURLs(arg0 context.Context, arg1 int64, arg2 PollGatewayURLsCallback) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PollGatewayURLs", arg0, arg1, arg2)
}

// PollGatewayURLs indicates an expected call of PollGatewayURLs.
func (mr *MockPollingGatewayURLQuerierMockRecorder) PollGatewayURLs(arg0, arg1, arg2 any) *MockPollingGatewayURLQuerierPollGatewayURLsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollGatewayURLs", reflect.TypeOf((*MockPollingGatewayURLQuerier)(nil).PollGatewayURLs), arg0, arg1, arg2)
	return &MockPollingGatewayURLQuerierPollGatewayURLsCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockPollingGatewayURLQuerierPollGatewayURLsCall) Do(f func(context.Context, int64, PollGatewayURLsCallback)) *MockPollingGatewayURLQuerierPollGatewayURLsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPollingGatewayURLQuerierPollGatewayURLsCall) DoAndReturn(f func(context.Context, int64, PollGatewayURLsCallback)) *MockPollingGatewayURLQuerierPollGatewayURLsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockRouterPlugin is a mock of RouterPlugin interface.
type MockRouterPlugin struct {
	ctrl     *gomock.Controller
	recorder *MockRouterPluginMockRecorder
}

// MockRouterPluginMockRecorder is the mock recorder for MockRouterPlugin.
type MockRouterPluginMockRecorder struct {
	mock *MockRouterPlugin
}

// NewMockRouterPlugin creates a new mock instance.
func NewMockRouterPlugin(ctrl *gomock.Controller) *MockRouterPlugin {
	mock := &MockRouterPlugin{ctrl: ctrl}
	mock.recorder = &MockRouterPluginMockRecorder{mock}
	return mock
}

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

// FindTunnel mocks base method.
func (m *MockRouterPlugin) FindTunnel(arg0 grpc.ServerStream, arg1 modshared.RPCAPI) (bool, *zap.Logger, FindHandle, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindTunnel", arg0, arg1)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(*zap.Logger)
	ret2, _ := ret[2].(FindHandle)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// FindTunnel indicates an expected call of FindTunnel.
func (mr *MockRouterPluginMockRecorder) FindTunnel(arg0, arg1 any) *MockRouterPluginFindTunnelCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindTunnel", reflect.TypeOf((*MockRouterPlugin)(nil).FindTunnel), arg0, arg1)
	return &MockRouterPluginFindTunnelCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRouterPluginFindTunnelCall) Return(arg0 bool, arg1 *zap.Logger, arg2 FindHandle, arg3 error) *MockRouterPluginFindTunnelCall {
	c.Call = c.Call.Return(arg0, arg1, arg2, arg3)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRouterPluginFindTunnelCall) Do(f func(grpc.ServerStream, modshared.RPCAPI) (bool, *zap.Logger, FindHandle, error)) *MockRouterPluginFindTunnelCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRouterPluginFindTunnelCall) DoAndReturn(f func(grpc.ServerStream, modshared.RPCAPI) (bool, *zap.Logger, FindHandle, error)) *MockRouterPluginFindTunnelCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GatewayFinderForStream mocks base method.
func (m *MockRouterPlugin) GatewayFinderForStream(arg0 grpc.ServerStream, arg1 modshared.RPCAPI) (GatewayFinder, *zap.Logger, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GatewayFinderForStream", arg0, arg1)
	ret0, _ := ret[0].(GatewayFinder)
	ret1, _ := ret[1].(*zap.Logger)
	ret2, _ := ret[2].(int64)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// GatewayFinderForStream indicates an expected call of GatewayFinderForStream.
func (mr *MockRouterPluginMockRecorder) GatewayFinderForStream(arg0, arg1 any) *MockRouterPluginGatewayFinderForStreamCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GatewayFinderForStream", reflect.TypeOf((*MockRouterPlugin)(nil).GatewayFinderForStream), arg0, arg1)
	return &MockRouterPluginGatewayFinderForStreamCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockRouterPluginGatewayFinderForStreamCall) Return(arg0 GatewayFinder, arg1 *zap.Logger, arg2 int64, arg3 error) *MockRouterPluginGatewayFinderForStreamCall {
	c.Call = c.Call.Return(arg0, arg1, arg2, arg3)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRouterPluginGatewayFinderForStreamCall) Do(f func(grpc.ServerStream, modshared.RPCAPI) (GatewayFinder, *zap.Logger, int64, error)) *MockRouterPluginGatewayFinderForStreamCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRouterPluginGatewayFinderForStreamCall) DoAndReturn(f func(grpc.ServerStream, modshared.RPCAPI) (GatewayFinder, *zap.Logger, int64, error)) *MockRouterPluginGatewayFinderForStreamCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}