interface.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ../pkg/ovs/interface.go

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

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	v1 "github.com/kubeovn/kube-ovn/pkg/apis/kubeovn/v1"
	ovs "github.com/kubeovn/kube-ovn/pkg/ovs"
	ovnnb "github.com/kubeovn/kube-ovn/pkg/ovsdb/ovnnb"
	ovnsb "github.com/kubeovn/kube-ovn/pkg/ovsdb/ovnsb"
	util "github.com/kubeovn/kube-ovn/pkg/util"
	ovsdb "github.com/ovn-org/libovsdb/ovsdb"
	v10 "k8s.io/api/networking/v1"
)

// MockNBGlobal is a mock of NBGlobal interface.
type MockNBGlobal struct {
	ctrl     *gomock.Controller
	recorder *MockNBGlobalMockRecorder
}

// MockNBGlobalMockRecorder is the mock recorder for MockNBGlobal.
type MockNBGlobalMockRecorder struct {
	mock *MockNBGlobal
}

// NewMockNBGlobal creates a new mock instance.
func NewMockNBGlobal(ctrl *gomock.Controller) *MockNBGlobal {
	mock := &MockNBGlobal{ctrl: ctrl}
	mock.recorder = &MockNBGlobalMockRecorder{mock}
	return mock
}

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

// GetNbGlobal mocks base method.
func (m *MockNBGlobal) GetNbGlobal() (*ovnnb.NBGlobal, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNbGlobal")
	ret0, _ := ret[0].(*ovnnb.NBGlobal)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// SetAzName indicates an expected call of SetAzName.
func (mr *MockNBGlobalMockRecorder) SetAzName(azName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAzName", reflect.TypeOf((*MockNBGlobal)(nil).SetAzName), azName)
}

// SetICAutoRoute mocks base method.
func (m *MockNBGlobal) SetICAutoRoute(enable bool, blackList []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetICAutoRoute", enable, blackList)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetICAutoRoute indicates an expected call of SetICAutoRoute.
func (mr *MockNBGlobalMockRecorder) SetICAutoRoute(enable, blackList interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetICAutoRoute", reflect.TypeOf((*MockNBGlobal)(nil).SetICAutoRoute), enable, blackList)
}

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

// SetLsCtSkipDstLportIPs indicates an expected call of SetLsCtSkipDstLportIPs.
func (mr *MockNBGlobalMockRecorder) SetLsCtSkipDstLportIPs(enabled interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLsCtSkipDstLportIPs", reflect.TypeOf((*MockNBGlobal)(nil).SetLsCtSkipDstLportIPs), enabled)
}

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

// SetLsDnatModDlDst indicates an expected call of SetLsDnatModDlDst.
func (mr *MockNBGlobalMockRecorder) SetLsDnatModDlDst(enabled interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLsDnatModDlDst", reflect.TypeOf((*MockNBGlobal)(nil).SetLsDnatModDlDst), enabled)
}

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

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

// UpdateNbGlobal mocks base method.
func (m *MockNBGlobal) UpdateNbGlobal(nbGlobal *ovnnb.NBGlobal, fields ...interface{}) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{nbGlobal}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateNbGlobal", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateNbGlobal indicates an expected call of UpdateNbGlobal.
func (mr *MockNBGlobalMockRecorder) UpdateNbGlobal(nbGlobal interface{}, fields ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{nbGlobal}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNbGlobal", reflect.TypeOf((*MockNBGlobal)(nil).UpdateNbGlobal), varargs...)
}

// MockLogicalRouter is a mock of LogicalRouter interface.
type MockLogicalRouter struct {
	ctrl     *gomock.Controller
	recorder *MockLogicalRouterMockRecorder
}

// MockLogicalRouterMockRecorder is the mock recorder for MockLogicalRouter.
type MockLogicalRouterMockRecorder struct {
	mock *MockLogicalRouter
}

// NewMockLogicalRouter creates a new mock instance.
func NewMockLogicalRouter(ctrl *gomock.Controller) *MockLogicalRouter {
	mock := &MockLogicalRouter{ctrl: ctrl}
	mock.recorder = &MockLogicalRouterMockRecorder{mock}
	return mock
}

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

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

// CreateLogicalRouter indicates an expected call of CreateLogicalRouter.
func (mr *MockLogicalRouterMockRecorder) CreateLogicalRouter(lrName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLogicalRouter", reflect.TypeOf((*MockLogicalRouter)(nil).CreateLogicalRouter), lrName)
}

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

// DeleteLogicalRouter indicates an expected call of DeleteLogicalRouter.
func (mr *MockLogicalRouterMockRecorder) DeleteLogicalRouter(lrName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouter", reflect.TypeOf((*MockLogicalRouter)(nil).DeleteLogicalRouter), lrName)
}

// GetLogicalRouter mocks base method.
func (m *MockLogicalRouter) GetLogicalRouter(lrName string, ignoreNotFound bool) (*ovnnb.LogicalRouter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogicalRouter", lrName, ignoreNotFound)
	ret0, _ := ret[0].(*ovnnb.LogicalRouter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogicalRouter indicates an expected call of GetLogicalRouter.
func (mr *MockLogicalRouterMockRecorder) GetLogicalRouter(lrName, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogicalRouter", reflect.TypeOf((*MockLogicalRouter)(nil).GetLogicalRouter), lrName, ignoreNotFound)
}

// ListLogicalRouter mocks base method.
func (m *MockLogicalRouter) ListLogicalRouter(needVendorFilter bool, filter func(*ovnnb.LogicalRouter) bool) ([]ovnnb.LogicalRouter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalRouter", needVendorFilter, filter)
	ret0, _ := ret[0].([]ovnnb.LogicalRouter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogicalRouter indicates an expected call of ListLogicalRouter.
func (mr *MockLogicalRouterMockRecorder) ListLogicalRouter(needVendorFilter, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogicalRouter", reflect.TypeOf((*MockLogicalRouter)(nil).ListLogicalRouter), needVendorFilter, filter)
}

// LogicalRouterExists mocks base method.
func (m *MockLogicalRouter) LogicalRouterExists(name string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogicalRouterExists", name)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogicalRouterExists indicates an expected call of LogicalRouterExists.
func (mr *MockLogicalRouterMockRecorder) LogicalRouterExists(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogicalRouterExists", reflect.TypeOf((*MockLogicalRouter)(nil).LogicalRouterExists), name)
}

// LogicalRouterUpdateLoadBalancers mocks base method.
func (m *MockLogicalRouter) LogicalRouterUpdateLoadBalancers(lrName string, op ovsdb.Mutator, lbNames ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{lrName, op}
	for _, a := range lbNames {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LogicalRouterUpdateLoadBalancers", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// LogicalRouterUpdateLoadBalancers indicates an expected call of LogicalRouterUpdateLoadBalancers.
func (mr *MockLogicalRouterMockRecorder) LogicalRouterUpdateLoadBalancers(lrName, op interface{}, lbNames ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{lrName, op}, lbNames...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogicalRouterUpdateLoadBalancers", reflect.TypeOf((*MockLogicalRouter)(nil).LogicalRouterUpdateLoadBalancers), varargs...)
}

// MockLogicalRouterPort is a mock of LogicalRouterPort interface.
type MockLogicalRouterPort struct {
	ctrl     *gomock.Controller
	recorder *MockLogicalRouterPortMockRecorder
}

// MockLogicalRouterPortMockRecorder is the mock recorder for MockLogicalRouterPort.
type MockLogicalRouterPortMockRecorder struct {
	mock *MockLogicalRouterPort
}

// NewMockLogicalRouterPort creates a new mock instance.
func NewMockLogicalRouterPort(ctrl *gomock.Controller) *MockLogicalRouterPort {
	mock := &MockLogicalRouterPort{ctrl: ctrl}
	mock.recorder = &MockLogicalRouterPortMockRecorder{mock}
	return mock
}

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

// CreateLogicalRouterPort mocks base method.
func (m *MockLogicalRouterPort) CreateLogicalRouterPort(lrName, lrpName, mac string, networks []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLogicalRouterPort", lrName, lrpName, mac, networks)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateLogicalRouterPort indicates an expected call of CreateLogicalRouterPort.
func (mr *MockLogicalRouterPortMockRecorder) CreateLogicalRouterPort(lrName, lrpName, mac, networks interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLogicalRouterPort", reflect.TypeOf((*MockLogicalRouterPort)(nil).CreateLogicalRouterPort), lrName, lrpName, mac, networks)
}

// CreatePeerRouterPort mocks base method.
func (m *MockLogicalRouterPort) CreatePeerRouterPort(localRouter, remoteRouter, localRouterPortIP string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePeerRouterPort", localRouter, remoteRouter, localRouterPortIP)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreatePeerRouterPort indicates an expected call of CreatePeerRouterPort.
func (mr *MockLogicalRouterPortMockRecorder) CreatePeerRouterPort(localRouter, remoteRouter, localRouterPortIP interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePeerRouterPort", reflect.TypeOf((*MockLogicalRouterPort)(nil).CreatePeerRouterPort), localRouter, remoteRouter, localRouterPortIP)
}

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

// DeleteLogicalRouterPort indicates an expected call of DeleteLogicalRouterPort.
func (mr *MockLogicalRouterPortMockRecorder) DeleteLogicalRouterPort(lrpName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouterPort", reflect.TypeOf((*MockLogicalRouterPort)(nil).DeleteLogicalRouterPort), lrpName)
}

// DeleteLogicalRouterPorts mocks base method.
func (m *MockLogicalRouterPort) DeleteLogicalRouterPorts(externalIDs map[string]string, filter func(*ovnnb.LogicalRouterPort) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLogicalRouterPorts", externalIDs, filter)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLogicalRouterPorts indicates an expected call of DeleteLogicalRouterPorts.
func (mr *MockLogicalRouterPortMockRecorder) DeleteLogicalRouterPorts(externalIDs, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouterPorts", reflect.TypeOf((*MockLogicalRouterPort)(nil).DeleteLogicalRouterPorts), externalIDs, filter)
}

// GetLogicalRouterPort mocks base method.
func (m *MockLogicalRouterPort) GetLogicalRouterPort(lrpName string, ignoreNotFound bool) (*ovnnb.LogicalRouterPort, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogicalRouterPort", lrpName, ignoreNotFound)
	ret0, _ := ret[0].(*ovnnb.LogicalRouterPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogicalRouterPort indicates an expected call of GetLogicalRouterPort.
func (mr *MockLogicalRouterPortMockRecorder) GetLogicalRouterPort(lrpName, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogicalRouterPort", reflect.TypeOf((*MockLogicalRouterPort)(nil).GetLogicalRouterPort), lrpName, ignoreNotFound)
}

// GetLogicalRouterPortByUUID mocks base method.
func (m *MockLogicalRouterPort) GetLogicalRouterPortByUUID(uuid string) (*ovnnb.LogicalRouterPort, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogicalRouterPortByUUID", uuid)
	ret0, _ := ret[0].(*ovnnb.LogicalRouterPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogicalRouterPortByUUID indicates an expected call of GetLogicalRouterPortByUUID.
func (mr *MockLogicalRouterPortMockRecorder) GetLogicalRouterPortByUUID(uuid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogicalRouterPortByUUID", reflect.TypeOf((*MockLogicalRouterPort)(nil).GetLogicalRouterPortByUUID), uuid)
}

// ListLogicalRouterPorts mocks base method.
func (m *MockLogicalRouterPort) ListLogicalRouterPorts(externalIDs map[string]string, filter func(*ovnnb.LogicalRouterPort) bool) ([]ovnnb.LogicalRouterPort, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalRouterPorts", externalIDs, filter)
	ret0, _ := ret[0].([]ovnnb.LogicalRouterPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogicalRouterPorts indicates an expected call of ListLogicalRouterPorts.
func (mr *MockLogicalRouterPortMockRecorder) ListLogicalRouterPorts(externalIDs, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogicalRouterPorts", reflect.TypeOf((*MockLogicalRouterPort)(nil).ListLogicalRouterPorts), externalIDs, filter)
}

// LogicalRouterPortExists mocks base method.
func (m *MockLogicalRouterPort) LogicalRouterPortExists(lrpName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogicalRouterPortExists", lrpName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogicalRouterPortExists indicates an expected call of LogicalRouterPortExists.
func (mr *MockLogicalRouterPortMockRecorder) LogicalRouterPortExists(lrpName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogicalRouterPortExists", reflect.TypeOf((*MockLogicalRouterPort)(nil).LogicalRouterPortExists), lrpName)
}

// UpdateLogicalRouterPortOptions mocks base method.
func (m *MockLogicalRouterPort) UpdateLogicalRouterPortOptions(lrpName string, options map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLogicalRouterPortOptions", lrpName, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateLogicalRouterPortOptions indicates an expected call of UpdateLogicalRouterPortOptions.
func (mr *MockLogicalRouterPortMockRecorder) UpdateLogicalRouterPortOptions(lrpName, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLogicalRouterPortOptions", reflect.TypeOf((*MockLogicalRouterPort)(nil).UpdateLogicalRouterPortOptions), lrpName, options)
}

// UpdateLogicalRouterPortRA mocks base method.
func (m *MockLogicalRouterPort) UpdateLogicalRouterPortRA(lrpName, ipv6RAConfigsStr string, enableIPv6RA bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLogicalRouterPortRA", lrpName, ipv6RAConfigsStr, enableIPv6RA)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateLogicalRouterPortRA indicates an expected call of UpdateLogicalRouterPortRA.
func (mr *MockLogicalRouterPortMockRecorder) UpdateLogicalRouterPortRA(lrpName, ipv6RAConfigsStr, enableIPv6RA interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLogicalRouterPortRA", reflect.TypeOf((*MockLogicalRouterPort)(nil).UpdateLogicalRouterPortRA), lrpName, ipv6RAConfigsStr, enableIPv6RA)
}

// MockBFD is a mock of BFD interface.
type MockBFD struct {
	ctrl     *gomock.Controller
	recorder *MockBFDMockRecorder
}

// MockBFDMockRecorder is the mock recorder for MockBFD.
type MockBFDMockRecorder struct {
	mock *MockBFD
}

// NewMockBFD creates a new mock instance.
func NewMockBFD(ctrl *gomock.Controller) *MockBFD {
	mock := &MockBFD{ctrl: ctrl}
	mock.recorder = &MockBFDMockRecorder{mock}
	return mock
}

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

// CreateBFD mocks base method.
func (m *MockBFD) CreateBFD(lrpName, dstIP string, minRx, minTx, detectMult int) (*ovnnb.BFD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBFD", lrpName, dstIP, minRx, minTx, detectMult)
	ret0, _ := ret[0].(*ovnnb.BFD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateBFD indicates an expected call of CreateBFD.
func (mr *MockBFDMockRecorder) CreateBFD(lrpName, dstIP, minRx, minTx, detectMult interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBFD", reflect.TypeOf((*MockBFD)(nil).CreateBFD), lrpName, dstIP, minRx, minTx, detectMult)
}

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

// DeleteBFD indicates an expected call of DeleteBFD.
func (mr *MockBFDMockRecorder) DeleteBFD(lrpName, dstIP interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBFD", reflect.TypeOf((*MockBFD)(nil).DeleteBFD), lrpName, dstIP)
}

// MockLogicalSwitch is a mock of LogicalSwitch interface.
type MockLogicalSwitch struct {
	ctrl     *gomock.Controller
	recorder *MockLogicalSwitchMockRecorder
}

// MockLogicalSwitchMockRecorder is the mock recorder for MockLogicalSwitch.
type MockLogicalSwitchMockRecorder struct {
	mock *MockLogicalSwitch
}

// NewMockLogicalSwitch creates a new mock instance.
func NewMockLogicalSwitch(ctrl *gomock.Controller) *MockLogicalSwitch {
	mock := &MockLogicalSwitch{ctrl: ctrl}
	mock.recorder = &MockLogicalSwitchMockRecorder{mock}
	return mock
}

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

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

// CreateBareLogicalSwitch indicates an expected call of CreateBareLogicalSwitch.
func (mr *MockLogicalSwitchMockRecorder) CreateBareLogicalSwitch(lsName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBareLogicalSwitch", reflect.TypeOf((*MockLogicalSwitch)(nil).CreateBareLogicalSwitch), lsName)
}

// CreateLogicalSwitch mocks base method.
func (m *MockLogicalSwitch) CreateLogicalSwitch(lsName, lrName, cidrBlock, gateway string, needRouter, randomAllocateGW bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLogicalSwitch", lsName, lrName, cidrBlock, gateway, needRouter, randomAllocateGW)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateLogicalSwitch indicates an expected call of CreateLogicalSwitch.
func (mr *MockLogicalSwitchMockRecorder) CreateLogicalSwitch(lsName, lrName, cidrBlock, gateway, needRouter, randomAllocateGW interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLogicalSwitch", reflect.TypeOf((*MockLogicalSwitch)(nil).CreateLogicalSwitch), lsName, lrName, cidrBlock, gateway, needRouter, randomAllocateGW)
}

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

// DeleteLogicalSwitch indicates an expected call of DeleteLogicalSwitch.
func (mr *MockLogicalSwitchMockRecorder) DeleteLogicalSwitch(lsName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalSwitch", reflect.TypeOf((*MockLogicalSwitch)(nil).DeleteLogicalSwitch), lsName)
}

// ListLogicalSwitch mocks base method.
func (m *MockLogicalSwitch) ListLogicalSwitch(needVendorFilter bool, filter func(*ovnnb.LogicalSwitch) bool) ([]ovnnb.LogicalSwitch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalSwitch", needVendorFilter, filter)
	ret0, _ := ret[0].([]ovnnb.LogicalSwitch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogicalSwitch indicates an expected call of ListLogicalSwitch.
func (mr *MockLogicalSwitchMockRecorder) ListLogicalSwitch(needVendorFilter, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogicalSwitch", reflect.TypeOf((*MockLogicalSwitch)(nil).ListLogicalSwitch), needVendorFilter, filter)
}

// LogicalSwitchExists mocks base method.
func (m *MockLogicalSwitch) LogicalSwitchExists(lsName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogicalSwitchExists", lsName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogicalSwitchExists indicates an expected call of LogicalSwitchExists.
func (mr *MockLogicalSwitchMockRecorder) LogicalSwitchExists(lsName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogicalSwitchExists", reflect.TypeOf((*MockLogicalSwitch)(nil).LogicalSwitchExists), lsName)
}

// LogicalSwitchUpdateLoadBalancers mocks base method.
func (m *MockLogicalSwitch) LogicalSwitchUpdateLoadBalancers(lsName string, op ovsdb.Mutator, lbNames ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{lsName, op}
	for _, a := range lbNames {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LogicalSwitchUpdateLoadBalancers", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// LogicalSwitchUpdateLoadBalancers indicates an expected call of LogicalSwitchUpdateLoadBalancers.
func (mr *MockLogicalSwitchMockRecorder) LogicalSwitchUpdateLoadBalancers(lsName, op interface{}, lbNames ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{lsName, op}, lbNames...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogicalSwitchUpdateLoadBalancers", reflect.TypeOf((*MockLogicalSwitch)(nil).LogicalSwitchUpdateLoadBalancers), varargs...)
}

// MockLogicalSwitchPort is a mock of LogicalSwitchPort interface.
type MockLogicalSwitchPort struct {
	ctrl     *gomock.Controller
	recorder *MockLogicalSwitchPortMockRecorder
}

// MockLogicalSwitchPortMockRecorder is the mock recorder for MockLogicalSwitchPort.
type MockLogicalSwitchPortMockRecorder struct {
	mock *MockLogicalSwitchPort
}

// NewMockLogicalSwitchPort creates a new mock instance.
func NewMockLogicalSwitchPort(ctrl *gomock.Controller) *MockLogicalSwitchPort {
	mock := &MockLogicalSwitchPort{ctrl: ctrl}
	mock.recorder = &MockLogicalSwitchPortMockRecorder{mock}
	return mock
}

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

// CreateBareLogicalSwitchPort mocks base method.
func (m *MockLogicalSwitchPort) CreateBareLogicalSwitchPort(lsName, lspName, ip, mac string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBareLogicalSwitchPort", lsName, lspName, ip, mac)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateBareLogicalSwitchPort indicates an expected call of CreateBareLogicalSwitchPort.
func (mr *MockLogicalSwitchPortMockRecorder) CreateBareLogicalSwitchPort(lsName, lspName, ip, mac interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBareLogicalSwitchPort", reflect.TypeOf((*MockLogicalSwitchPort)(nil).CreateBareLogicalSwitchPort), lsName, lspName, ip, mac)
}

// CreateLocalnetLogicalSwitchPort mocks base method.
func (m *MockLogicalSwitchPort) CreateLocalnetLogicalSwitchPort(lsName, lspName, provider string, vlanID int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLocalnetLogicalSwitchPort", lsName, lspName, provider, vlanID)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateLocalnetLogicalSwitchPort indicates an expected call of CreateLocalnetLogicalSwitchPort.
func (mr *MockLogicalSwitchPortMockRecorder) CreateLocalnetLogicalSwitchPort(lsName, lspName, provider, vlanID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalnetLogicalSwitchPort", reflect.TypeOf((*MockLogicalSwitchPort)(nil).CreateLocalnetLogicalSwitchPort), lsName, lspName, provider, vlanID)
}

// CreateLogicalSwitchPort mocks base method.
func (m *MockLogicalSwitchPort) CreateLogicalSwitchPort(lsName, lspName, ip, mac, podName, namespace string, portSecurity bool, securityGroups, vips string, enableDHCP bool, dhcpOptions *ovs.DHCPOptionsUUIDs, vpc string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLogicalSwitchPort", lsName, lspName, ip, mac, podName, namespace, portSecurity, securityGroups, vips, enableDHCP, dhcpOptions, vpc)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateLogicalSwitchPort indicates an expected call of CreateLogicalSwitchPort.
func (mr *MockLogicalSwitchPortMockRecorder) CreateLogicalSwitchPort(lsName, lspName, ip, mac, podName, namespace, portSecurity, securityGroups, vips, enableDHCP, dhcpOptions, vpc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLogicalSwitchPort", reflect.TypeOf((*MockLogicalSwitchPort)(nil).CreateLogicalSwitchPort), lsName, lspName, ip, mac, podName, namespace, portSecurity, securityGroups, vips, enableDHCP, dhcpOptions, vpc)
}

// CreateVirtualLogicalSwitchPorts mocks base method.
func (m *MockLogicalSwitchPort) CreateVirtualLogicalSwitchPorts(lsName string, ips ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{lsName}
	for _, a := range ips {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVirtualLogicalSwitchPorts", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateVirtualLogicalSwitchPorts indicates an expected call of CreateVirtualLogicalSwitchPorts.
func (mr *MockLogicalSwitchPortMockRecorder) CreateVirtualLogicalSwitchPorts(lsName interface{}, ips ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{lsName}, ips...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVirtualLogicalSwitchPorts", reflect.TypeOf((*MockLogicalSwitchPort)(nil).CreateVirtualLogicalSwitchPorts), varargs...)
}

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

// DeleteLogicalSwitchPort indicates an expected call of DeleteLogicalSwitchPort.
func (mr *MockLogicalSwitchPortMockRecorder) DeleteLogicalSwitchPort(lspName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalSwitchPort", reflect.TypeOf((*MockLogicalSwitchPort)(nil).DeleteLogicalSwitchPort), lspName)
}

// DeleteLogicalSwitchPorts mocks base method.
func (m *MockLogicalSwitchPort) DeleteLogicalSwitchPorts(externalIDs map[string]string, filter func(*ovnnb.LogicalSwitchPort) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLogicalSwitchPorts", externalIDs, filter)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLogicalSwitchPorts indicates an expected call of DeleteLogicalSwitchPorts.
func (mr *MockLogicalSwitchPortMockRecorder) DeleteLogicalSwitchPorts(externalIDs, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalSwitchPorts", reflect.TypeOf((*MockLogicalSwitchPort)(nil).DeleteLogicalSwitchPorts), externalIDs, filter)
}

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

// EnablePortLayer2forward indicates an expected call of EnablePortLayer2forward.
func (mr *MockLogicalSwitchPortMockRecorder) EnablePortLayer2forward(lspName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnablePortLayer2forward", reflect.TypeOf((*MockLogicalSwitchPort)(nil).EnablePortLayer2forward), lspName)
}

// GetLogicalSwitchPort mocks base method.
func (m *MockLogicalSwitchPort) GetLogicalSwitchPort(lspName string, ignoreNotFound bool) (*ovnnb.LogicalSwitchPort, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogicalSwitchPort", lspName, ignoreNotFound)
	ret0, _ := ret[0].(*ovnnb.LogicalSwitchPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogicalSwitchPort indicates an expected call of GetLogicalSwitchPort.
func (mr *MockLogicalSwitchPortMockRecorder) GetLogicalSwitchPort(lspName, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogicalSwitchPort", reflect.TypeOf((*MockLogicalSwitchPort)(nil).GetLogicalSwitchPort), lspName, ignoreNotFound)
}

// ListLogicalSwitchPorts mocks base method.
func (m *MockLogicalSwitchPort) ListLogicalSwitchPorts(needVendorFilter bool, externalIDs map[string]string, filter func(*ovnnb.LogicalSwitchPort) bool) ([]ovnnb.LogicalSwitchPort, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalSwitchPorts", needVendorFilter, externalIDs, filter)
	ret0, _ := ret[0].([]ovnnb.LogicalSwitchPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogicalSwitchPorts indicates an expected call of ListLogicalSwitchPorts.
func (mr *MockLogicalSwitchPortMockRecorder) ListLogicalSwitchPorts(needVendorFilter, externalIDs, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogicalSwitchPorts", reflect.TypeOf((*MockLogicalSwitchPort)(nil).ListLogicalSwitchPorts), needVendorFilter, externalIDs, filter)
}

// ListLogicalSwitchPortsWithLegacyExternalIDs mocks base method.
func (m *MockLogicalSwitchPort) ListLogicalSwitchPortsWithLegacyExternalIDs() ([]ovnnb.LogicalSwitchPort, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalSwitchPortsWithLegacyExternalIDs")
	ret0, _ := ret[0].([]ovnnb.LogicalSwitchPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNormalLogicalSwitchPorts mocks base method.
func (m *MockLogicalSwitchPort) ListNormalLogicalSwitchPorts(needVendorFilter bool, externalIDs map[string]string) ([]ovnnb.LogicalSwitchPort, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNormalLogicalSwitchPorts", needVendorFilter, externalIDs)
	ret0, _ := ret[0].([]ovnnb.LogicalSwitchPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNormalLogicalSwitchPorts indicates an expected call of ListNormalLogicalSwitchPorts.
func (mr *MockLogicalSwitchPortMockRecorder) ListNormalLogicalSwitchPorts(needVendorFilter, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNormalLogicalSwitchPorts", reflect.TypeOf((*MockLogicalSwitchPort)(nil).ListNormalLogicalSwitchPorts), needVendorFilter, externalIDs)
}

// LogicalSwitchPortExists mocks base method.
func (m *MockLogicalSwitchPort) LogicalSwitchPortExists(name string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogicalSwitchPortExists", name)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogicalSwitchPortExists indicates an expected call of LogicalSwitchPortExists.
func (mr *MockLogicalSwitchPortMockRecorder) LogicalSwitchPortExists(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogicalSwitchPortExists", reflect.TypeOf((*MockLogicalSwitchPort)(nil).LogicalSwitchPortExists), name)
}

// SetLogicalSwitchPortArpProxy mocks base method.
func (m *MockLogicalSwitchPort) SetLogicalSwitchPortArpProxy(lspName string, enableArpProxy bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLogicalSwitchPortArpProxy", lspName, enableArpProxy)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLogicalSwitchPortArpProxy indicates an expected call of SetLogicalSwitchPortArpProxy.
func (mr *MockLogicalSwitchPortMockRecorder) SetLogicalSwitchPortArpProxy(lspName, enableArpProxy interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogicalSwitchPortArpProxy", reflect.TypeOf((*MockLogicalSwitchPort)(nil).SetLogicalSwitchPortArpProxy), lspName, enableArpProxy)
}

// SetLogicalSwitchPortExternalIds mocks base method.
func (m *MockLogicalSwitchPort) SetLogicalSwitchPortExternalIds(lspName string, externalIds map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLogicalSwitchPortExternalIds", lspName, externalIds)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLogicalSwitchPortExternalIds indicates an expected call of SetLogicalSwitchPortExternalIds.
func (mr *MockLogicalSwitchPortMockRecorder) SetLogicalSwitchPortExternalIds(lspName, externalIds interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogicalSwitchPortExternalIds", reflect.TypeOf((*MockLogicalSwitchPort)(nil).SetLogicalSwitchPortExternalIds), lspName, externalIds)
}

// SetLogicalSwitchPortSecurity mocks base method.
func (m *MockLogicalSwitchPort) SetLogicalSwitchPortSecurity(portSecurity bool, lspName, mac, ips, vips string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLogicalSwitchPortSecurity", portSecurity, lspName, mac, ips, vips)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLogicalSwitchPortSecurity indicates an expected call of SetLogicalSwitchPortSecurity.
func (mr *MockLogicalSwitchPortMockRecorder) SetLogicalSwitchPortSecurity(portSecurity, lspName, mac, ips, vips interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogicalSwitchPortSecurity", reflect.TypeOf((*MockLogicalSwitchPort)(nil).SetLogicalSwitchPortSecurity), portSecurity, lspName, mac, ips, vips)
}

// SetLogicalSwitchPortVirtualParents mocks base method.
func (m *MockLogicalSwitchPort) SetLogicalSwitchPortVirtualParents(lsName, parents string, ips ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{lsName, parents}
	for _, a := range ips {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetLogicalSwitchPortVirtualParents", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLogicalSwitchPortVirtualParents indicates an expected call of SetLogicalSwitchPortVirtualParents.
func (mr *MockLogicalSwitchPortMockRecorder) SetLogicalSwitchPortVirtualParents(lsName, parents interface{}, ips ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{lsName, parents}, ips...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogicalSwitchPortVirtualParents", reflect.TypeOf((*MockLogicalSwitchPort)(nil).SetLogicalSwitchPortVirtualParents), varargs...)
}

// SetLogicalSwitchPortVlanTag mocks base method.
func (m *MockLogicalSwitchPort) SetLogicalSwitchPortVlanTag(lspName string, vlanID int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLogicalSwitchPortVlanTag", lspName, vlanID)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLogicalSwitchPortVlanTag indicates an expected call of SetLogicalSwitchPortVlanTag.
func (mr *MockLogicalSwitchPortMockRecorder) SetLogicalSwitchPortVlanTag(lspName, vlanID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogicalSwitchPortVlanTag", reflect.TypeOf((*MockLogicalSwitchPort)(nil).SetLogicalSwitchPortVlanTag), lspName, vlanID)
}

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

// SetLogicalSwitchPortsSecurityGroup indicates an expected call of SetLogicalSwitchPortsSecurityGroup.
func (mr *MockLogicalSwitchPortMockRecorder) SetLogicalSwitchPortsSecurityGroup(sgName, op interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogicalSwitchPortsSecurityGroup", reflect.TypeOf((*MockLogicalSwitchPort)(nil).SetLogicalSwitchPortsSecurityGroup), sgName, op)
}

// MockLoadBalancer is a mock of LoadBalancer interface.
type MockLoadBalancer struct {
	ctrl     *gomock.Controller
	recorder *MockLoadBalancerMockRecorder
}

// MockLoadBalancerMockRecorder is the mock recorder for MockLoadBalancer.
type MockLoadBalancerMockRecorder struct {
	mock *MockLoadBalancer
}

// NewMockLoadBalancer creates a new mock instance.
func NewMockLoadBalancer(ctrl *gomock.Controller) *MockLoadBalancer {
	mock := &MockLoadBalancer{ctrl: ctrl}
	mock.recorder = &MockLoadBalancerMockRecorder{mock}
	return mock
}

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

// CreateLoadBalancer mocks base method.
func (m *MockLoadBalancer) CreateLoadBalancer(lbName, protocol, selectFields string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLoadBalancer", lbName, protocol, selectFields)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateLoadBalancer indicates an expected call of CreateLoadBalancer.
func (mr *MockLoadBalancerMockRecorder) CreateLoadBalancer(lbName, protocol, selectFields interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancer", reflect.TypeOf((*MockLoadBalancer)(nil).CreateLoadBalancer), lbName, protocol, selectFields)
}

// DeleteLoadBalancers mocks base method.
func (m *MockLoadBalancer) DeleteLoadBalancers(filter func(*ovnnb.LoadBalancer) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLoadBalancers", filter)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLoadBalancers indicates an expected call of DeleteLoadBalancers.
func (mr *MockLoadBalancerMockRecorder) DeleteLoadBalancers(filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancers", reflect.TypeOf((*MockLoadBalancer)(nil).DeleteLoadBalancers), filter)
}

// GetLoadBalancer mocks base method.
func (m *MockLoadBalancer) GetLoadBalancer(lbName string, ignoreNotFound bool) (*ovnnb.LoadBalancer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLoadBalancer", lbName, ignoreNotFound)
	ret0, _ := ret[0].(*ovnnb.LoadBalancer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLoadBalancer indicates an expected call of GetLoadBalancer.
func (mr *MockLoadBalancerMockRecorder) GetLoadBalancer(lbName, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancer", reflect.TypeOf((*MockLoadBalancer)(nil).GetLoadBalancer), lbName, ignoreNotFound)
}

// ListLoadBalancers mocks base method.
func (m *MockLoadBalancer) ListLoadBalancers(filter func(*ovnnb.LoadBalancer) bool) ([]ovnnb.LoadBalancer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLoadBalancers", filter)
	ret0, _ := ret[0].([]ovnnb.LoadBalancer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLoadBalancers indicates an expected call of ListLoadBalancers.
func (mr *MockLoadBalancerMockRecorder) ListLoadBalancers(filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLoadBalancers", reflect.TypeOf((*MockLoadBalancer)(nil).ListLoadBalancers), filter)
}

// LoadBalancerAddHealthCheck mocks base method.
func (m *MockLoadBalancer) LoadBalancerAddHealthCheck(lbName, vip string, ignoreHealthCheck bool, ipPortMapping, externals map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancerAddHealthCheck", lbName, vip, ignoreHealthCheck, ipPortMapping, externals)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadBalancerAddHealthCheck indicates an expected call of LoadBalancerAddHealthCheck.
func (mr *MockLoadBalancerMockRecorder) LoadBalancerAddHealthCheck(lbName, vip, ignoreHealthCheck, ipPortMapping, externals interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerAddHealthCheck", reflect.TypeOf((*MockLoadBalancer)(nil).LoadBalancerAddHealthCheck), lbName, vip, ignoreHealthCheck, ipPortMapping, externals)
}

// LoadBalancerAddIPPortMapping mocks base method.
func (m *MockLoadBalancer) LoadBalancerAddIPPortMapping(lbName, vip string, ipPortMappings map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancerAddIPPortMapping", lbName, vip, ipPortMappings)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadBalancerAddIPPortMapping indicates an expected call of LoadBalancerAddIPPortMapping.
func (mr *MockLoadBalancerMockRecorder) LoadBalancerAddIPPortMapping(lbName, vip, ipPortMappings interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerAddIPPortMapping", reflect.TypeOf((*MockLoadBalancer)(nil).LoadBalancerAddIPPortMapping), lbName, vip, ipPortMappings)
}

// LoadBalancerAddVip mocks base method.
func (m *MockLoadBalancer) LoadBalancerAddVip(lbName, vip string, backends ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{lbName, vip}
	for _, a := range backends {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LoadBalancerAddVip", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadBalancerAddVip indicates an expected call of LoadBalancerAddVip.
func (mr *MockLoadBalancerMockRecorder) LoadBalancerAddVip(lbName, vip interface{}, backends ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{lbName, vip}, backends...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerAddVip", reflect.TypeOf((*MockLoadBalancer)(nil).LoadBalancerAddVip), varargs...)
}

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

// LoadBalancerDeleteHealthCheck indicates an expected call of LoadBalancerDeleteHealthCheck.
func (mr *MockLoadBalancerMockRecorder) LoadBalancerDeleteHealthCheck(lbName, uuid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerDeleteHealthCheck", reflect.TypeOf((*MockLoadBalancer)(nil).LoadBalancerDeleteHealthCheck), lbName, uuid)
}

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

// LoadBalancerDeleteIPPortMapping indicates an expected call of LoadBalancerDeleteIPPortMapping.
func (mr *MockLoadBalancerMockRecorder) LoadBalancerDeleteIPPortMapping(lbName, vip interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerDeleteIPPortMapping", reflect.TypeOf((*MockLoadBalancer)(nil).LoadBalancerDeleteIPPortMapping), lbName, vip)
}

// LoadBalancerDeleteVip mocks base method.
func (m *MockLoadBalancer) LoadBalancerDeleteVip(lbName, vip string, ignoreHealthCheck bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancerDeleteVip", lbName, vip, ignoreHealthCheck)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadBalancerDeleteVip indicates an expected call of LoadBalancerDeleteVip.
func (mr *MockLoadBalancerMockRecorder) LoadBalancerDeleteVip(lbName, vip, ignoreHealthCheck interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerDeleteVip", reflect.TypeOf((*MockLoadBalancer)(nil).LoadBalancerDeleteVip), lbName, vip, ignoreHealthCheck)
}

// LoadBalancerExists mocks base method.
func (m *MockLoadBalancer) LoadBalancerExists(lbName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancerExists", lbName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadBalancerExists indicates an expected call of LoadBalancerExists.
func (mr *MockLoadBalancerMockRecorder) LoadBalancerExists(lbName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerExists", reflect.TypeOf((*MockLoadBalancer)(nil).LoadBalancerExists), lbName)
}

// LoadBalancerUpdateIPPortMapping mocks base method.
func (m *MockLoadBalancer) LoadBalancerUpdateIPPortMapping(lbName, vip string, ipPortMappings map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancerUpdateIPPortMapping", lbName, vip, ipPortMappings)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadBalancerUpdateIPPortMapping indicates an expected call of LoadBalancerUpdateIPPortMapping.
func (mr *MockLoadBalancerMockRecorder) LoadBalancerUpdateIPPortMapping(lbName, vip, ipPortMappings interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerUpdateIPPortMapping", reflect.TypeOf((*MockLoadBalancer)(nil).LoadBalancerUpdateIPPortMapping), lbName, vip, ipPortMappings)
}

// SetLoadBalancerAffinityTimeout mocks base method.
func (m *MockLoadBalancer) SetLoadBalancerAffinityTimeout(lbName string, timeout int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLoadBalancerAffinityTimeout", lbName, timeout)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLoadBalancerAffinityTimeout indicates an expected call of SetLoadBalancerAffinityTimeout.
func (mr *MockLoadBalancerMockRecorder) SetLoadBalancerAffinityTimeout(lbName, timeout interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerAffinityTimeout", reflect.TypeOf((*MockLoadBalancer)(nil).SetLoadBalancerAffinityTimeout), lbName, timeout)
}

// MockLoadBalancerHealthCheck is a mock of LoadBalancerHealthCheck interface.
type MockLoadBalancerHealthCheck struct {
	ctrl     *gomock.Controller
	recorder *MockLoadBalancerHealthCheckMockRecorder
}

// MockLoadBalancerHealthCheckMockRecorder is the mock recorder for MockLoadBalancerHealthCheck.
type MockLoadBalancerHealthCheckMockRecorder struct {
	mock *MockLoadBalancerHealthCheck
}

// NewMockLoadBalancerHealthCheck creates a new mock instance.
func NewMockLoadBalancerHealthCheck(ctrl *gomock.Controller) *MockLoadBalancerHealthCheck {
	mock := &MockLoadBalancerHealthCheck{ctrl: ctrl}
	mock.recorder = &MockLoadBalancerHealthCheckMockRecorder{mock}
	return mock
}

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

// AddLoadBalancerHealthCheck mocks base method.
func (m *MockLoadBalancerHealthCheck) AddLoadBalancerHealthCheck(lbName, vip string, externals map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddLoadBalancerHealthCheck", lbName, vip, externals)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddLoadBalancerHealthCheck indicates an expected call of AddLoadBalancerHealthCheck.
func (mr *MockLoadBalancerHealthCheckMockRecorder) AddLoadBalancerHealthCheck(lbName, vip, externals interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLoadBalancerHealthCheck", reflect.TypeOf((*MockLoadBalancerHealthCheck)(nil).AddLoadBalancerHealthCheck), lbName, vip, externals)
}

// CreateLoadBalancerHealthCheck mocks base method.
func (m *MockLoadBalancerHealthCheck) CreateLoadBalancerHealthCheck(lbName, vip string, lbhc *ovnnb.LoadBalancerHealthCheck) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLoadBalancerHealthCheck", lbName, vip, lbhc)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateLoadBalancerHealthCheck indicates an expected call of CreateLoadBalancerHealthCheck.
func (mr *MockLoadBalancerHealthCheckMockRecorder) CreateLoadBalancerHealthCheck(lbName, vip, lbhc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerHealthCheck", reflect.TypeOf((*MockLoadBalancerHealthCheck)(nil).CreateLoadBalancerHealthCheck), lbName, vip, lbhc)
}

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

// DeleteLoadBalancerHealthCheck indicates an expected call of DeleteLoadBalancerHealthCheck.
func (mr *MockLoadBalancerHealthCheckMockRecorder) DeleteLoadBalancerHealthCheck(lbName, vip interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerHealthCheck", reflect.TypeOf((*MockLoadBalancerHealthCheck)(nil).DeleteLoadBalancerHealthCheck), lbName, vip)
}

// DeleteLoadBalancerHealthChecks mocks base method.
func (m *MockLoadBalancerHealthCheck) DeleteLoadBalancerHealthChecks(filter func(*ovnnb.LoadBalancerHealthCheck) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLoadBalancerHealthChecks", filter)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLoadBalancerHealthChecks indicates an expected call of DeleteLoadBalancerHealthChecks.
func (mr *MockLoadBalancerHealthCheckMockRecorder) DeleteLoadBalancerHealthChecks(filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerHealthChecks", reflect.TypeOf((*MockLoadBalancerHealthCheck)(nil).DeleteLoadBalancerHealthChecks), filter)
}

// GetLoadBalancerHealthCheck mocks base method.
func (m *MockLoadBalancerHealthCheck) GetLoadBalancerHealthCheck(lbName, vip string, ignoreNotFound bool) (*ovnnb.LoadBalancer, *ovnnb.LoadBalancerHealthCheck, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLoadBalancerHealthCheck", lbName, vip, ignoreNotFound)
	ret0, _ := ret[0].(*ovnnb.LoadBalancer)
	ret1, _ := ret[1].(*ovnnb.LoadBalancerHealthCheck)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetLoadBalancerHealthCheck indicates an expected call of GetLoadBalancerHealthCheck.
func (mr *MockLoadBalancerHealthCheckMockRecorder) GetLoadBalancerHealthCheck(lbName, vip, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancerHealthCheck", reflect.TypeOf((*MockLoadBalancerHealthCheck)(nil).GetLoadBalancerHealthCheck), lbName, vip, ignoreNotFound)
}

// ListLoadBalancerHealthChecks mocks base method.
func (m *MockLoadBalancerHealthCheck) ListLoadBalancerHealthChecks(filter func(*ovnnb.LoadBalancerHealthCheck) bool) ([]ovnnb.LoadBalancerHealthCheck, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLoadBalancerHealthChecks", filter)
	ret0, _ := ret[0].([]ovnnb.LoadBalancerHealthCheck)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLoadBalancerHealthChecks indicates an expected call of ListLoadBalancerHealthChecks.
func (mr *MockLoadBalancerHealthCheckMockRecorder) ListLoadBalancerHealthChecks(filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLoadBalancerHealthChecks", reflect.TypeOf((*MockLoadBalancerHealthCheck)(nil).ListLoadBalancerHealthChecks), filter)
}

// LoadBalancerHealthCheckExists mocks base method.
func (m *MockLoadBalancerHealthCheck) LoadBalancerHealthCheckExists(lbName, vip string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancerHealthCheckExists", lbName, vip)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadBalancerHealthCheckExists indicates an expected call of LoadBalancerHealthCheckExists.
func (mr *MockLoadBalancerHealthCheckMockRecorder) LoadBalancerHealthCheckExists(lbName, vip interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerHealthCheckExists", reflect.TypeOf((*MockLoadBalancerHealthCheck)(nil).LoadBalancerHealthCheckExists), lbName, vip)
}

// MockPortGroup is a mock of PortGroup interface.
type MockPortGroup struct {
	ctrl     *gomock.Controller
	recorder *MockPortGroupMockRecorder
}

// MockPortGroupMockRecorder is the mock recorder for MockPortGroup.
type MockPortGroupMockRecorder struct {
	mock *MockPortGroup
}

// NewMockPortGroup creates a new mock instance.
func NewMockPortGroup(ctrl *gomock.Controller) *MockPortGroup {
	mock := &MockPortGroup{ctrl: ctrl}
	mock.recorder = &MockPortGroupMockRecorder{mock}
	return mock
}

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

// CreatePortGroup mocks base method.
func (m *MockPortGroup) CreatePortGroup(pgName string, externalIDs map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePortGroup", pgName, externalIDs)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreatePortGroup indicates an expected call of CreatePortGroup.
func (mr *MockPortGroupMockRecorder) CreatePortGroup(pgName, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePortGroup", reflect.TypeOf((*MockPortGroup)(nil).CreatePortGroup), pgName, externalIDs)
}

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

// DeletePortGroup indicates an expected call of DeletePortGroup.
func (mr *MockPortGroupMockRecorder) DeletePortGroup(pgName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePortGroup", reflect.TypeOf((*MockPortGroup)(nil).DeletePortGroup), pgName)
}

// GetPortGroup mocks base method.
func (m *MockPortGroup) GetPortGroup(pgName string, ignoreNotFound bool) (*ovnnb.PortGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPortGroup", pgName, ignoreNotFound)
	ret0, _ := ret[0].(*ovnnb.PortGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPortGroup indicates an expected call of GetPortGroup.
func (mr *MockPortGroupMockRecorder) GetPortGroup(pgName, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPortGroup", reflect.TypeOf((*MockPortGroup)(nil).GetPortGroup), pgName, ignoreNotFound)
}

// ListPortGroups mocks base method.
func (m *MockPortGroup) ListPortGroups(externalIDs map[string]string) ([]ovnnb.PortGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPortGroups", externalIDs)
	ret0, _ := ret[0].([]ovnnb.PortGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPortGroups indicates an expected call of ListPortGroups.
func (mr *MockPortGroupMockRecorder) ListPortGroups(externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPortGroups", reflect.TypeOf((*MockPortGroup)(nil).ListPortGroups), externalIDs)
}

// PortGroupAddPorts mocks base method.
func (m *MockPortGroup) PortGroupAddPorts(pgName string, lspNames ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{pgName}
	for _, a := range lspNames {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PortGroupAddPorts", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// PortGroupAddPorts indicates an expected call of PortGroupAddPorts.
func (mr *MockPortGroupMockRecorder) PortGroupAddPorts(pgName interface{}, lspNames ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{pgName}, lspNames...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PortGroupAddPorts", reflect.TypeOf((*MockPortGroup)(nil).PortGroupAddPorts), varargs...)
}

// PortGroupExists mocks base method.
func (m *MockPortGroup) PortGroupExists(pgName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PortGroupExists", pgName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PortGroupExists indicates an expected call of PortGroupExists.
func (mr *MockPortGroupMockRecorder) PortGroupExists(pgName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PortGroupExists", reflect.TypeOf((*MockPortGroup)(nil).PortGroupExists), pgName)
}

// PortGroupRemovePorts mocks base method.
func (m *MockPortGroup) PortGroupRemovePorts(pgName string, lspNames ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{pgName}
	for _, a := range lspNames {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PortGroupRemovePorts", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// PortGroupRemovePorts indicates an expected call of PortGroupRemovePorts.
func (mr *MockPortGroupMockRecorder) PortGroupRemovePorts(pgName interface{}, lspNames ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{pgName}, lspNames...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PortGroupRemovePorts", reflect.TypeOf((*MockPortGroup)(nil).PortGroupRemovePorts), varargs...)
}

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

// PortGroupSetPorts indicates an expected call of PortGroupSetPorts.
func (mr *MockPortGroupMockRecorder) PortGroupSetPorts(pgName, ports interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PortGroupSetPorts", reflect.TypeOf((*MockPortGroup)(nil).PortGroupSetPorts), pgName, ports)
}

// MockACL is a mock of ACL interface.
type MockACL struct {
	ctrl     *gomock.Controller
	recorder *MockACLMockRecorder
}

// MockACLMockRecorder is the mock recorder for MockACL.
type MockACLMockRecorder struct {
	mock *MockACL
}

// NewMockACL creates a new mock instance.
func NewMockACL(ctrl *gomock.Controller) *MockACL {
	mock := &MockACL{ctrl: ctrl}
	mock.recorder = &MockACLMockRecorder{mock}
	return mock
}

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

// CreateGatewayACL mocks base method.
func (m *MockACL) CreateGatewayACL(lsName, pgName, gateway string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGatewayACL", lsName, pgName, gateway)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateGatewayACL indicates an expected call of CreateGatewayACL.
func (mr *MockACLMockRecorder) CreateGatewayACL(lsName, pgName, gateway interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGatewayACL", reflect.TypeOf((*MockACL)(nil).CreateGatewayACL), lsName, pgName, gateway)
}

// CreateNodeACL mocks base method.
func (m *MockACL) CreateNodeACL(pgName, nodeIPStr, joinIPStr string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNodeACL", pgName, nodeIPStr, joinIPStr)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateNodeACL indicates an expected call of CreateNodeACL.
func (mr *MockACLMockRecorder) CreateNodeACL(pgName, nodeIPStr, joinIPStr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNodeACL", reflect.TypeOf((*MockACL)(nil).CreateNodeACL), pgName, nodeIPStr, joinIPStr)
}

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

// CreateSgBaseACL indicates an expected call of CreateSgBaseACL.
func (mr *MockACLMockRecorder) CreateSgBaseACL(sgName, direction interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSgBaseACL", reflect.TypeOf((*MockACL)(nil).CreateSgBaseACL), sgName, direction)
}

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

// CreateSgDenyAllACL indicates an expected call of CreateSgDenyAllACL.
func (mr *MockACLMockRecorder) CreateSgDenyAllACL(sgName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSgDenyAllACL", reflect.TypeOf((*MockACL)(nil).CreateSgDenyAllACL), sgName)
}

// DeleteAcls mocks base method.
func (m *MockACL) DeleteAcls(parentName, parentType, direction string, externalIDs map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAcls", parentName, parentType, direction, externalIDs)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteAcls indicates an expected call of DeleteAcls.
func (mr *MockACLMockRecorder) DeleteAcls(parentName, parentType, direction, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAcls", reflect.TypeOf((*MockACL)(nil).DeleteAcls), parentName, parentType, direction, externalIDs)
}

// DeleteAclsOps mocks base method.
func (m *MockACL) DeleteAclsOps(parentName, parentType, direction string, externalIDs map[string]string) ([]ovsdb.Operation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAclsOps", parentName, parentType, direction, externalIDs)
	ret0, _ := ret[0].([]ovsdb.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAclsOps indicates an expected call of DeleteAclsOps.
func (mr *MockACLMockRecorder) DeleteAclsOps(parentName, parentType, direction, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAclsOps", reflect.TypeOf((*MockACL)(nil).DeleteAclsOps), parentName, parentType, direction, externalIDs)
}

// SetACLLog mocks base method.
func (m *MockACL) SetACLLog(pgName, protocol string, logEnable, isIngress bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetACLLog", pgName, protocol, logEnable, isIngress)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetACLLog indicates an expected call of SetACLLog.
func (mr *MockACLMockRecorder) SetACLLog(pgName, protocol, logEnable, isIngress interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetACLLog", reflect.TypeOf((*MockACL)(nil).SetACLLog), pgName, protocol, logEnable, isIngress)
}

// SetLogicalSwitchPrivate mocks base method.
func (m *MockACL) SetLogicalSwitchPrivate(lsName, cidrBlock, nodeSwitchCIDR string, allowSubnets []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLogicalSwitchPrivate", lsName, cidrBlock, nodeSwitchCIDR, allowSubnets)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLogicalSwitchPrivate indicates an expected call of SetLogicalSwitchPrivate.
func (mr *MockACLMockRecorder) SetLogicalSwitchPrivate(lsName, cidrBlock, nodeSwitchCIDR, allowSubnets interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogicalSwitchPrivate", reflect.TypeOf((*MockACL)(nil).SetLogicalSwitchPrivate), lsName, cidrBlock, nodeSwitchCIDR, allowSubnets)
}

// UpdateEgressACLOps mocks base method.
func (m *MockACL) UpdateEgressACLOps(pgName, asEgressName, asExceptName, protocol string, npp []v10.NetworkPolicyPort, logEnable bool, namedPortMap map[string]*util.NamedPortInfo) ([]ovsdb.Operation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateEgressACLOps", pgName, asEgressName, asExceptName, protocol, npp, logEnable, namedPortMap)
	ret0, _ := ret[0].([]ovsdb.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateEgressACLOps indicates an expected call of UpdateEgressACLOps.
func (mr *MockACLMockRecorder) UpdateEgressACLOps(pgName, asEgressName, asExceptName, protocol, npp, logEnable, namedPortMap interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEgressACLOps", reflect.TypeOf((*MockACL)(nil).UpdateEgressACLOps), pgName, asEgressName, asExceptName, protocol, npp, logEnable, namedPortMap)
}

// UpdateIngressACLOps mocks base method.
func (m *MockACL) UpdateIngressACLOps(pgName, asIngressName, asExceptName, protocol string, npp []v10.NetworkPolicyPort, logEnable bool, namedPortMap map[string]*util.NamedPortInfo) ([]ovsdb.Operation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIngressACLOps", pgName, asIngressName, asExceptName, protocol, npp, logEnable, namedPortMap)
	ret0, _ := ret[0].([]ovsdb.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateIngressACLOps indicates an expected call of UpdateIngressACLOps.
func (mr *MockACLMockRecorder) UpdateIngressACLOps(pgName, asIngressName, asExceptName, protocol, npp, logEnable, namedPortMap interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIngressACLOps", reflect.TypeOf((*MockACL)(nil).UpdateIngressACLOps), pgName, asIngressName, asExceptName, protocol, npp, logEnable, namedPortMap)
}

// UpdateLogicalSwitchACL mocks base method.
func (m *MockACL) UpdateLogicalSwitchACL(lsName string, subnetAcls []v1.ACL) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLogicalSwitchACL", lsName, subnetAcls)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateLogicalSwitchACL indicates an expected call of UpdateLogicalSwitchACL.
func (mr *MockACLMockRecorder) UpdateLogicalSwitchACL(lsName, subnetAcls interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLogicalSwitchACL", reflect.TypeOf((*MockACL)(nil).UpdateLogicalSwitchACL), lsName, subnetAcls)
}

// UpdateSgACL mocks base method.
func (m *MockACL) UpdateSgACL(sg *v1.SecurityGroup, direction string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSgACL", sg, direction)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateSgACL indicates an expected call of UpdateSgACL.
func (mr *MockACLMockRecorder) UpdateSgACL(sg, direction interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSgACL", reflect.TypeOf((*MockACL)(nil).UpdateSgACL), sg, direction)
}

// MockAddressSet is a mock of AddressSet interface.
type MockAddressSet struct {
	ctrl     *gomock.Controller
	recorder *MockAddressSetMockRecorder
}

// MockAddressSetMockRecorder is the mock recorder for MockAddressSet.
type MockAddressSetMockRecorder struct {
	mock *MockAddressSet
}

// NewMockAddressSet creates a new mock instance.
func NewMockAddressSet(ctrl *gomock.Controller) *MockAddressSet {
	mock := &MockAddressSet{ctrl: ctrl}
	mock.recorder = &MockAddressSetMockRecorder{mock}
	return mock
}

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

// AddressSetUpdateAddress mocks base method.
func (m *MockAddressSet) AddressSetUpdateAddress(asName string, addresses ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{asName}
	for _, a := range addresses {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddressSetUpdateAddress", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddressSetUpdateAddress indicates an expected call of AddressSetUpdateAddress.
func (mr *MockAddressSetMockRecorder) AddressSetUpdateAddress(asName interface{}, addresses ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{asName}, addresses...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddressSetUpdateAddress", reflect.TypeOf((*MockAddressSet)(nil).AddressSetUpdateAddress), varargs...)
}

// CreateAddressSet mocks base method.
func (m *MockAddressSet) CreateAddressSet(asName string, externalIDs map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAddressSet", asName, externalIDs)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateAddressSet indicates an expected call of CreateAddressSet.
func (mr *MockAddressSetMockRecorder) CreateAddressSet(asName, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAddressSet", reflect.TypeOf((*MockAddressSet)(nil).CreateAddressSet), asName, externalIDs)
}

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

// DeleteAddressSet indicates an expected call of DeleteAddressSet.
func (mr *MockAddressSetMockRecorder) DeleteAddressSet(asName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAddressSet", reflect.TypeOf((*MockAddressSet)(nil).DeleteAddressSet), asName)
}

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

// DeleteAddressSets indicates an expected call of DeleteAddressSets.
func (mr *MockAddressSetMockRecorder) DeleteAddressSets(externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAddressSets", reflect.TypeOf((*MockAddressSet)(nil).DeleteAddressSets), externalIDs)
}

// ListAddressSets mocks base method.
func (m *MockAddressSet) ListAddressSets(externalIDs map[string]string) ([]ovnnb.AddressSet, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAddressSets", externalIDs)
	ret0, _ := ret[0].([]ovnnb.AddressSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAddressSets indicates an expected call of ListAddressSets.
func (mr *MockAddressSetMockRecorder) ListAddressSets(externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAddressSets", reflect.TypeOf((*MockAddressSet)(nil).ListAddressSets), externalIDs)
}

// MockLogicalRouterStaticRoute is a mock of LogicalRouterStaticRoute interface.
type MockLogicalRouterStaticRoute struct {
	ctrl     *gomock.Controller
	recorder *MockLogicalRouterStaticRouteMockRecorder
}

// MockLogicalRouterStaticRouteMockRecorder is the mock recorder for MockLogicalRouterStaticRoute.
type MockLogicalRouterStaticRouteMockRecorder struct {
	mock *MockLogicalRouterStaticRoute
}

// NewMockLogicalRouterStaticRoute creates a new mock instance.
func NewMockLogicalRouterStaticRoute(ctrl *gomock.Controller) *MockLogicalRouterStaticRoute {
	mock := &MockLogicalRouterStaticRoute{ctrl: ctrl}
	mock.recorder = &MockLogicalRouterStaticRouteMockRecorder{mock}
	return mock
}

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

// AddLogicalRouterStaticRoute mocks base method.
func (m *MockLogicalRouterStaticRoute) AddLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix string, bfdID *string, nexthops ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{lrName, routeTable, policy, ipPrefix, bfdID}
	for _, a := range nexthops {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddLogicalRouterStaticRoute", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddLogicalRouterStaticRoute indicates an expected call of AddLogicalRouterStaticRoute.
func (mr *MockLogicalRouterStaticRouteMockRecorder) AddLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix, bfdID interface{}, nexthops ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{lrName, routeTable, policy, ipPrefix, bfdID}, nexthops...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLogicalRouterStaticRoute", reflect.TypeOf((*MockLogicalRouterStaticRoute)(nil).AddLogicalRouterStaticRoute), varargs...)
}

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

// ClearLogicalRouterStaticRoute indicates an expected call of ClearLogicalRouterStaticRoute.
func (mr *MockLogicalRouterStaticRouteMockRecorder) ClearLogicalRouterStaticRoute(lrName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearLogicalRouterStaticRoute", reflect.TypeOf((*MockLogicalRouterStaticRoute)(nil).ClearLogicalRouterStaticRoute), lrName)
}

// DeleteLogicalRouterStaticRoute mocks base method.
func (m *MockLogicalRouterStaticRoute) DeleteLogicalRouterStaticRoute(lrName string, routeTable, policy *string, ipPrefix, nextHop string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLogicalRouterStaticRoute", lrName, routeTable, policy, ipPrefix, nextHop)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLogicalRouterStaticRoute indicates an expected call of DeleteLogicalRouterStaticRoute.
func (mr *MockLogicalRouterStaticRouteMockRecorder) DeleteLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix, nextHop interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouterStaticRoute", reflect.TypeOf((*MockLogicalRouterStaticRoute)(nil).DeleteLogicalRouterStaticRoute), lrName, routeTable, policy, ipPrefix, nextHop)
}

// ListLogicalRouterStaticRoutes mocks base method.
func (m *MockLogicalRouterStaticRoute) ListLogicalRouterStaticRoutes(lrName string, routeTable, policy *string, ipPrefix string, externalIDs map[string]string) ([]*ovnnb.LogicalRouterStaticRoute, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalRouterStaticRoutes", lrName, routeTable, policy, ipPrefix, externalIDs)
	ret0, _ := ret[0].([]*ovnnb.LogicalRouterStaticRoute)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogicalRouterStaticRoutes indicates an expected call of ListLogicalRouterStaticRoutes.
func (mr *MockLogicalRouterStaticRouteMockRecorder) ListLogicalRouterStaticRoutes(lrName, routeTable, policy, ipPrefix, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogicalRouterStaticRoutes", reflect.TypeOf((*MockLogicalRouterStaticRoute)(nil).ListLogicalRouterStaticRoutes), lrName, routeTable, policy, ipPrefix, externalIDs)
}

// ListLogicalRouterStaticRoutesByOption mocks base method.
func (m *MockLogicalRouterStaticRoute) ListLogicalRouterStaticRoutesByOption(lrName, routeTable, key, value string) ([]*ovnnb.LogicalRouterStaticRoute, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalRouterStaticRoutesByOption", lrName, routeTable, key, value)
	ret0, _ := ret[0].([]*ovnnb.LogicalRouterStaticRoute)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogicalRouterStaticRoutesByOption indicates an expected call of ListLogicalRouterStaticRoutesByOption.
func (mr *MockLogicalRouterStaticRouteMockRecorder) ListLogicalRouterStaticRoutesByOption(lrName, routeTable, key, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogicalRouterStaticRoutesByOption", reflect.TypeOf((*MockLogicalRouterStaticRoute)(nil).ListLogicalRouterStaticRoutesByOption), lrName, routeTable, key, value)
}

// LogicalRouterStaticRouteExists mocks base method.
func (m *MockLogicalRouterStaticRoute) LogicalRouterStaticRouteExists(lrName, routeTable, policy, ipPrefix, nexthop string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogicalRouterStaticRouteExists", lrName, routeTable, policy, ipPrefix, nexthop)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogicalRouterStaticRouteExists indicates an expected call of LogicalRouterStaticRouteExists.
func (mr *MockLogicalRouterStaticRouteMockRecorder) LogicalRouterStaticRouteExists(lrName, routeTable, policy, ipPrefix, nexthop interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogicalRouterStaticRouteExists", reflect.TypeOf((*MockLogicalRouterStaticRoute)(nil).LogicalRouterStaticRouteExists), lrName, routeTable, policy, ipPrefix, nexthop)
}

// MockLogicalRouterPolicy is a mock of LogicalRouterPolicy interface.
type MockLogicalRouterPolicy struct {
	ctrl     *gomock.Controller
	recorder *MockLogicalRouterPolicyMockRecorder
}

// MockLogicalRouterPolicyMockRecorder is the mock recorder for MockLogicalRouterPolicy.
type MockLogicalRouterPolicyMockRecorder struct {
	mock *MockLogicalRouterPolicy
}

// NewMockLogicalRouterPolicy creates a new mock instance.
func NewMockLogicalRouterPolicy(ctrl *gomock.Controller) *MockLogicalRouterPolicy {
	mock := &MockLogicalRouterPolicy{ctrl: ctrl}
	mock.recorder = &MockLogicalRouterPolicyMockRecorder{mock}
	return mock
}

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

// AddLogicalRouterPolicy mocks base method.
func (m *MockLogicalRouterPolicy) AddLogicalRouterPolicy(lrName string, priority int, match, action string, nextHops []string, externalIDs map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddLogicalRouterPolicy", lrName, priority, match, action, nextHops, externalIDs)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddLogicalRouterPolicy indicates an expected call of AddLogicalRouterPolicy.
func (mr *MockLogicalRouterPolicyMockRecorder) AddLogicalRouterPolicy(lrName, priority, match, action, nextHops, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLogicalRouterPolicy", reflect.TypeOf((*MockLogicalRouterPolicy)(nil).AddLogicalRouterPolicy), lrName, priority, match, action, nextHops, externalIDs)
}

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

// ClearLogicalRouterPolicy indicates an expected call of ClearLogicalRouterPolicy.
func (mr *MockLogicalRouterPolicyMockRecorder) ClearLogicalRouterPolicy(lrName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearLogicalRouterPolicy", reflect.TypeOf((*MockLogicalRouterPolicy)(nil).ClearLogicalRouterPolicy), lrName)
}

// DeleteLogicalRouterPolicies mocks base method.
func (m *MockLogicalRouterPolicy) DeleteLogicalRouterPolicies(lrName string, priority int, externalIDs map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLogicalRouterPolicies", lrName, priority, externalIDs)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLogicalRouterPolicies indicates an expected call of DeleteLogicalRouterPolicies.
func (mr *MockLogicalRouterPolicyMockRecorder) DeleteLogicalRouterPolicies(lrName, priority, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouterPolicies", reflect.TypeOf((*MockLogicalRouterPolicy)(nil).DeleteLogicalRouterPolicies), lrName, priority, externalIDs)
}

// DeleteLogicalRouterPolicy mocks base method.
func (m *MockLogicalRouterPolicy) DeleteLogicalRouterPolicy(lrName string, priority int, match string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLogicalRouterPolicy", lrName, priority, match)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLogicalRouterPolicy indicates an expected call of DeleteLogicalRouterPolicy.
func (mr *MockLogicalRouterPolicyMockRecorder) DeleteLogicalRouterPolicy(lrName, priority, match interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouterPolicy", reflect.TypeOf((*MockLogicalRouterPolicy)(nil).DeleteLogicalRouterPolicy), lrName, priority, match)
}

// DeleteLogicalRouterPolicyByNexthop mocks base method.
func (m *MockLogicalRouterPolicy) DeleteLogicalRouterPolicyByNexthop(lrName string, priority int, nexthop string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLogicalRouterPolicyByNexthop", lrName, priority, nexthop)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLogicalRouterPolicyByNexthop indicates an expected call of DeleteLogicalRouterPolicyByNexthop.
func (mr *MockLogicalRouterPolicyMockRecorder) DeleteLogicalRouterPolicyByNexthop(lrName, priority, nexthop interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouterPolicyByNexthop", reflect.TypeOf((*MockLogicalRouterPolicy)(nil).DeleteLogicalRouterPolicyByNexthop), lrName, priority, nexthop)
}

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

// DeleteLogicalRouterPolicyByUUID indicates an expected call of DeleteLogicalRouterPolicyByUUID.
func (mr *MockLogicalRouterPolicyMockRecorder) DeleteLogicalRouterPolicyByUUID(lrName, uuid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouterPolicyByUUID", reflect.TypeOf((*MockLogicalRouterPolicy)(nil).DeleteLogicalRouterPolicyByUUID), lrName, uuid)
}

// GetLogicalRouterPoliciesByExtID mocks base method.
func (m *MockLogicalRouterPolicy) GetLogicalRouterPoliciesByExtID(lrName, key, value string) ([]*ovnnb.LogicalRouterPolicy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogicalRouterPoliciesByExtID", lrName, key, value)
	ret0, _ := ret[0].([]*ovnnb.LogicalRouterPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogicalRouterPoliciesByExtID indicates an expected call of GetLogicalRouterPoliciesByExtID.
func (mr *MockLogicalRouterPolicyMockRecorder) GetLogicalRouterPoliciesByExtID(lrName, key, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogicalRouterPoliciesByExtID", reflect.TypeOf((*MockLogicalRouterPolicy)(nil).GetLogicalRouterPoliciesByExtID), lrName, key, value)
}

// GetLogicalRouterPolicy mocks base method.
func (m *MockLogicalRouterPolicy) GetLogicalRouterPolicy(lrName string, priority int, match string, ignoreNotFound bool) ([]*ovnnb.LogicalRouterPolicy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogicalRouterPolicy", lrName, priority, match, ignoreNotFound)
	ret0, _ := ret[0].([]*ovnnb.LogicalRouterPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogicalRouterPolicy indicates an expected call of GetLogicalRouterPolicy.
func (mr *MockLogicalRouterPolicyMockRecorder) GetLogicalRouterPolicy(lrName, priority, match, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogicalRouterPolicy", reflect.TypeOf((*MockLogicalRouterPolicy)(nil).GetLogicalRouterPolicy), lrName, priority, match, ignoreNotFound)
}

// ListLogicalRouterPolicies mocks base method.
func (m *MockLogicalRouterPolicy) ListLogicalRouterPolicies(lrName string, priority int, externalIDs map[string]string, ignoreExtIDEmptyValue bool) ([]*ovnnb.LogicalRouterPolicy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalRouterPolicies", lrName, priority, externalIDs, ignoreExtIDEmptyValue)
	ret0, _ := ret[0].([]*ovnnb.LogicalRouterPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogicalRouterPolicies indicates an expected call of ListLogicalRouterPolicies.
func (mr *MockLogicalRouterPolicyMockRecorder) ListLogicalRouterPolicies(lrName, priority, externalIDs, ignoreExtIDEmptyValue interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogicalRouterPolicies", reflect.TypeOf((*MockLogicalRouterPolicy)(nil).ListLogicalRouterPolicies), lrName, priority, externalIDs, ignoreExtIDEmptyValue)
}

// MockNAT is a mock of NAT interface.
type MockNAT struct {
	ctrl     *gomock.Controller
	recorder *MockNATMockRecorder
}

// MockNATMockRecorder is the mock recorder for MockNAT.
type MockNATMockRecorder struct {
	mock *MockNAT
}

// NewMockNAT creates a new mock instance.
func NewMockNAT(ctrl *gomock.Controller) *MockNAT {
	mock := &MockNAT{ctrl: ctrl}
	mock.recorder = &MockNATMockRecorder{mock}
	return mock
}

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

// AddNat mocks base method.
func (m *MockNAT) AddNat(lrName, natType, externalIP, logicalIP, logicalMac, port string, options map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddNat", lrName, natType, externalIP, logicalIP, logicalMac, port, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddNat indicates an expected call of AddNat.
func (mr *MockNATMockRecorder) AddNat(lrName, natType, externalIP, logicalIP, logicalMac, port, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNat", reflect.TypeOf((*MockNAT)(nil).AddNat), lrName, natType, externalIP, logicalIP, logicalMac, port, options)
}

// DeleteNat mocks base method.
func (m *MockNAT) DeleteNat(lrName, natType, externalIP, logicalIP string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNat", lrName, natType, externalIP, logicalIP)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNat indicates an expected call of DeleteNat.
func (mr *MockNATMockRecorder) DeleteNat(lrName, natType, externalIP, logicalIP interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNat", reflect.TypeOf((*MockNAT)(nil).DeleteNat), lrName, natType, externalIP, logicalIP)
}

// DeleteNats mocks base method.
func (m *MockNAT) DeleteNats(lrName, natType, logicalIP string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNats", lrName, natType, logicalIP)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNats indicates an expected call of DeleteNats.
func (mr *MockNATMockRecorder) DeleteNats(lrName, natType, logicalIP interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNats", reflect.TypeOf((*MockNAT)(nil).DeleteNats), lrName, natType, logicalIP)
}

// GetNATByUUID mocks base method.
func (m *MockNAT) GetNATByUUID(uuid string) (*ovnnb.NAT, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNATByUUID", uuid)
	ret0, _ := ret[0].(*ovnnb.NAT)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNATByUUID indicates an expected call of GetNATByUUID.
func (mr *MockNATMockRecorder) GetNATByUUID(uuid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNATByUUID", reflect.TypeOf((*MockNAT)(nil).GetNATByUUID), uuid)
}

// ListNats mocks base method.
func (m *MockNAT) ListNats(lrName, natType, logicalIP string, externalIDs map[string]string) ([]*ovnnb.NAT, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNats", lrName, natType, logicalIP, externalIDs)
	ret0, _ := ret[0].([]*ovnnb.NAT)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNats indicates an expected call of ListNats.
func (mr *MockNATMockRecorder) ListNats(lrName, natType, logicalIP, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNats", reflect.TypeOf((*MockNAT)(nil).ListNats), lrName, natType, logicalIP, externalIDs)
}

// NatExists mocks base method.
func (m *MockNAT) NatExists(lrName, natType, externalIP, logicalIP string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NatExists", lrName, natType, externalIP, logicalIP)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NatExists indicates an expected call of NatExists.
func (mr *MockNATMockRecorder) NatExists(lrName, natType, externalIP, logicalIP interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NatExists", reflect.TypeOf((*MockNAT)(nil).NatExists), lrName, natType, externalIP, logicalIP)
}

// UpdateDnatAndSnat mocks base method.
func (m *MockNAT) UpdateDnatAndSnat(lrName, externalIP, logicalIP, lspName, externalMac, gatewayType string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDnatAndSnat", lrName, externalIP, logicalIP, lspName, externalMac, gatewayType)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDnatAndSnat indicates an expected call of UpdateDnatAndSnat.
func (mr *MockNATMockRecorder) UpdateDnatAndSnat(lrName, externalIP, logicalIP, lspName, externalMac, gatewayType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDnatAndSnat", reflect.TypeOf((*MockNAT)(nil).UpdateDnatAndSnat), lrName, externalIP, logicalIP, lspName, externalMac, gatewayType)
}

// UpdateSnat mocks base method.
func (m *MockNAT) UpdateSnat(lrName, externalIP, logicalIP string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSnat", lrName, externalIP, logicalIP)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateSnat indicates an expected call of UpdateSnat.
func (mr *MockNATMockRecorder) UpdateSnat(lrName, externalIP, logicalIP interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSnat", reflect.TypeOf((*MockNAT)(nil).UpdateSnat), lrName, externalIP, logicalIP)
}

// MockDHCPOptions is a mock of DHCPOptions interface.
type MockDHCPOptions struct {
	ctrl     *gomock.Controller
	recorder *MockDHCPOptionsMockRecorder
}

// MockDHCPOptionsMockRecorder is the mock recorder for MockDHCPOptions.
type MockDHCPOptionsMockRecorder struct {
	mock *MockDHCPOptions
}

// NewMockDHCPOptions creates a new mock instance.
func NewMockDHCPOptions(ctrl *gomock.Controller) *MockDHCPOptions {
	mock := &MockDHCPOptions{ctrl: ctrl}
	mock.recorder = &MockDHCPOptionsMockRecorder{mock}
	return mock
}

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

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

// DeleteDHCPOptions indicates an expected call of DeleteDHCPOptions.
func (mr *MockDHCPOptionsMockRecorder) DeleteDHCPOptions(lsName, protocol interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDHCPOptions", reflect.TypeOf((*MockDHCPOptions)(nil).DeleteDHCPOptions), lsName, protocol)
}

// DeleteDHCPOptionsByUUIDs mocks base method.
func (m *MockDHCPOptions) DeleteDHCPOptionsByUUIDs(uuidList ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range uuidList {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteDHCPOptionsByUUIDs", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDHCPOptionsByUUIDs indicates an expected call of DeleteDHCPOptionsByUUIDs.
func (mr *MockDHCPOptionsMockRecorder) DeleteDHCPOptionsByUUIDs(uuidList ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDHCPOptionsByUUIDs", reflect.TypeOf((*MockDHCPOptions)(nil).DeleteDHCPOptionsByUUIDs), uuidList...)
}

// ListDHCPOptions mocks base method.
func (m *MockDHCPOptions) ListDHCPOptions(needVendorFilter bool, externalIDs map[string]string) ([]ovnnb.DHCPOptions, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDHCPOptions", needVendorFilter, externalIDs)
	ret0, _ := ret[0].([]ovnnb.DHCPOptions)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDHCPOptions indicates an expected call of ListDHCPOptions.
func (mr *MockDHCPOptionsMockRecorder) ListDHCPOptions(needVendorFilter, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDHCPOptions", reflect.TypeOf((*MockDHCPOptions)(nil).ListDHCPOptions), needVendorFilter, externalIDs)
}

// UpdateDHCPOptions mocks base method.
func (m *MockDHCPOptions) UpdateDHCPOptions(subnet *v1.Subnet, mtu int) (*ovs.DHCPOptionsUUIDs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDHCPOptions", subnet, mtu)
	ret0, _ := ret[0].(*ovs.DHCPOptionsUUIDs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDHCPOptions indicates an expected call of UpdateDHCPOptions.
func (mr *MockDHCPOptionsMockRecorder) UpdateDHCPOptions(subnet, mtu interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDHCPOptions", reflect.TypeOf((*MockDHCPOptions)(nil).UpdateDHCPOptions), subnet, mtu)
}

// MockNbClient is a mock of NbClient interface.
type MockNbClient struct {
	ctrl     *gomock.Controller
	recorder *MockNbClientMockRecorder
}

// MockNbClientMockRecorder is the mock recorder for MockNbClient.
type MockNbClientMockRecorder struct {
	mock *MockNbClient
}

// NewMockNbClient creates a new mock instance.
func NewMockNbClient(ctrl *gomock.Controller) *MockNbClient {
	mock := &MockNbClient{ctrl: ctrl}
	mock.recorder = &MockNbClientMockRecorder{mock}
	return mock
}

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

// AddLoadBalancerHealthCheck mocks base method.
func (m *MockNbClient) AddLoadBalancerHealthCheck(lbName, vip string, externals map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddLoadBalancerHealthCheck", lbName, vip, externals)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddLoadBalancerHealthCheck indicates an expected call of AddLoadBalancerHealthCheck.
func (mr *MockNbClientMockRecorder) AddLoadBalancerHealthCheck(lbName, vip, externals interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLoadBalancerHealthCheck", reflect.TypeOf((*MockNbClient)(nil).AddLoadBalancerHealthCheck), lbName, vip, externals)
}

// AddLogicalRouterPolicy mocks base method.
func (m *MockNbClient) AddLogicalRouterPolicy(lrName string, priority int, match, action string, nextHops []string, externalIDs map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddLogicalRouterPolicy", lrName, priority, match, action, nextHops, externalIDs)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddLogicalRouterPolicy indicates an expected call of AddLogicalRouterPolicy.
func (mr *MockNbClientMockRecorder) AddLogicalRouterPolicy(lrName, priority, match, action, nextHops, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLogicalRouterPolicy", reflect.TypeOf((*MockNbClient)(nil).AddLogicalRouterPolicy), lrName, priority, match, action, nextHops, externalIDs)
}

// AddLogicalRouterStaticRoute mocks base method.
func (m *MockNbClient) AddLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix string, bfdID *string, nexthops ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{lrName, routeTable, policy, ipPrefix, bfdID}
	for _, a := range nexthops {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddLogicalRouterStaticRoute", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddLogicalRouterStaticRoute indicates an expected call of AddLogicalRouterStaticRoute.
func (mr *MockNbClientMockRecorder) AddLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix, bfdID interface{}, nexthops ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{lrName, routeTable, policy, ipPrefix, bfdID}, nexthops...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLogicalRouterStaticRoute", reflect.TypeOf((*MockNbClient)(nil).AddLogicalRouterStaticRoute), varargs...)
}

// AddNat mocks base method.
func (m *MockNbClient) AddNat(lrName, natType, externalIP, logicalIP, logicalMac, port string, options map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddNat", lrName, natType, externalIP, logicalIP, logicalMac, port, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddNat indicates an expected call of AddNat.
func (mr *MockNbClientMockRecorder) AddNat(lrName, natType, externalIP, logicalIP, logicalMac, port, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNat", reflect.TypeOf((*MockNbClient)(nil).AddNat), lrName, natType, externalIP, logicalIP, logicalMac, port, options)
}

// AddressSetUpdateAddress mocks base method.
func (m *MockNbClient) AddressSetUpdateAddress(asName string, addresses ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{asName}
	for _, a := range addresses {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddressSetUpdateAddress", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddressSetUpdateAddress indicates an expected call of AddressSetUpdateAddress.
func (mr *MockNbClientMockRecorder) AddressSetUpdateAddress(asName interface{}, addresses ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{asName}, addresses...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddressSetUpdateAddress", reflect.TypeOf((*MockNbClient)(nil).AddressSetUpdateAddress), varargs...)
}

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

// ClearLogicalRouterPolicy indicates an expected call of ClearLogicalRouterPolicy.
func (mr *MockNbClientMockRecorder) ClearLogicalRouterPolicy(lrName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearLogicalRouterPolicy", reflect.TypeOf((*MockNbClient)(nil).ClearLogicalRouterPolicy), lrName)
}

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

// ClearLogicalRouterStaticRoute indicates an expected call of ClearLogicalRouterStaticRoute.
func (mr *MockNbClientMockRecorder) ClearLogicalRouterStaticRoute(lrName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearLogicalRouterStaticRoute", reflect.TypeOf((*MockNbClient)(nil).ClearLogicalRouterStaticRoute), lrName)
}

// CreateAddressSet mocks base method.
func (m *MockNbClient) CreateAddressSet(asName string, externalIDs map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAddressSet", asName, externalIDs)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateAddressSet indicates an expected call of CreateAddressSet.
func (mr *MockNbClientMockRecorder) CreateAddressSet(asName, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAddressSet", reflect.TypeOf((*MockNbClient)(nil).CreateAddressSet), asName, externalIDs)
}

// CreateBFD mocks base method.
func (m *MockNbClient) CreateBFD(lrpName, dstIP string, minRx, minTx, detectMult int) (*ovnnb.BFD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBFD", lrpName, dstIP, minRx, minTx, detectMult)
	ret0, _ := ret[0].(*ovnnb.BFD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateBFD indicates an expected call of CreateBFD.
func (mr *MockNbClientMockRecorder) CreateBFD(lrpName, dstIP, minRx, minTx, detectMult interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBFD", reflect.TypeOf((*MockNbClient)(nil).CreateBFD), lrpName, dstIP, minRx, minTx, detectMult)
}

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

// CreateBareLogicalSwitch indicates an expected call of CreateBareLogicalSwitch.
func (mr *MockNbClientMockRecorder) CreateBareLogicalSwitch(lsName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBareLogicalSwitch", reflect.TypeOf((*MockNbClient)(nil).CreateBareLogicalSwitch), lsName)
}

// CreateBareLogicalSwitchPort mocks base method.
func (m *MockNbClient) CreateBareLogicalSwitchPort(lsName, lspName, ip, mac string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBareLogicalSwitchPort", lsName, lspName, ip, mac)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateBareLogicalSwitchPort indicates an expected call of CreateBareLogicalSwitchPort.
func (mr *MockNbClientMockRecorder) CreateBareLogicalSwitchPort(lsName, lspName, ip, mac interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBareLogicalSwitchPort", reflect.TypeOf((*MockNbClient)(nil).CreateBareLogicalSwitchPort), lsName, lspName, ip, mac)
}

// CreateGatewayACL mocks base method.
func (m *MockNbClient) CreateGatewayACL(lsName, pgName, gateway string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGatewayACL", lsName, pgName, gateway)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateGatewayACL indicates an expected call of CreateGatewayACL.
func (mr *MockNbClientMockRecorder) CreateGatewayACL(lsName, pgName, gateway interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGatewayACL", reflect.TypeOf((*MockNbClient)(nil).CreateGatewayACL), lsName, pgName, gateway)
}

// CreateGatewayLogicalSwitch mocks base method.
func (m *MockNbClient) CreateGatewayLogicalSwitch(lsName, lrName, provider, ip, mac string, vlanID int, chassises ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{lsName, lrName, provider, ip, mac, vlanID}
	for _, a := range chassises {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateGatewayLogicalSwitch", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateGatewayLogicalSwitch indicates an expected call of CreateGatewayLogicalSwitch.
func (mr *MockNbClientMockRecorder) CreateGatewayLogicalSwitch(lsName, lrName, provider, ip, mac, vlanID interface{}, chassises ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{lsName, lrName, provider, ip, mac, vlanID}, chassises...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGatewayLogicalSwitch", reflect.TypeOf((*MockNbClient)(nil).CreateGatewayLogicalSwitch), varargs...)
}

// CreateLoadBalancer mocks base method.
func (m *MockNbClient) CreateLoadBalancer(lbName, protocol, selectFields string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLoadBalancer", lbName, protocol, selectFields)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateLoadBalancer indicates an expected call of CreateLoadBalancer.
func (mr *MockNbClientMockRecorder) CreateLoadBalancer(lbName, protocol, selectFields interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancer", reflect.TypeOf((*MockNbClient)(nil).CreateLoadBalancer), lbName, protocol, selectFields)
}

// CreateLoadBalancerHealthCheck mocks base method.
func (m *MockNbClient) CreateLoadBalancerHealthCheck(lbName, vip string, lbhc *ovnnb.LoadBalancerHealthCheck) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLoadBalancerHealthCheck", lbName, vip, lbhc)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateLoadBalancerHealthCheck indicates an expected call of CreateLoadBalancerHealthCheck.
func (mr *MockNbClientMockRecorder) CreateLoadBalancerHealthCheck(lbName, vip, lbhc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerHealthCheck", reflect.TypeOf((*MockNbClient)(nil).CreateLoadBalancerHealthCheck), lbName, vip, lbhc)
}

// CreateLocalnetLogicalSwitchPort mocks base method.
func (m *MockNbClient) CreateLocalnetLogicalSwitchPort(lsName, lspName, provider string, vlanID int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLocalnetLogicalSwitchPort", lsName, lspName, provider, vlanID)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateLocalnetLogicalSwitchPort indicates an expected call of CreateLocalnetLogicalSwitchPort.
func (mr *MockNbClientMockRecorder) CreateLocalnetLogicalSwitchPort(lsName, lspName, provider, vlanID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalnetLogicalSwitchPort", reflect.TypeOf((*MockNbClient)(nil).CreateLocalnetLogicalSwitchPort), lsName, lspName, provider, vlanID)
}

// CreateLogicalPatchPort mocks base method.
func (m *MockNbClient) CreateLogicalPatchPort(lsName, lrName, lspName, lrpName, ip, mac string, chassises ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{lsName, lrName, lspName, lrpName, ip, mac}
	for _, a := range chassises {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateLogicalPatchPort", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateLogicalPatchPort indicates an expected call of CreateLogicalPatchPort.
func (mr *MockNbClientMockRecorder) CreateLogicalPatchPort(lsName, lrName, lspName, lrpName, ip, mac interface{}, chassises ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{lsName, lrName, lspName, lrpName, ip, mac}, chassises...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLogicalPatchPort", reflect.TypeOf((*MockNbClient)(nil).CreateLogicalPatchPort), varargs...)
}

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

// CreateLogicalRouter indicates an expected call of CreateLogicalRouter.
func (mr *MockNbClientMockRecorder) CreateLogicalRouter(lrName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLogicalRouter", reflect.TypeOf((*MockNbClient)(nil).CreateLogicalRouter), lrName)
}

// CreateLogicalRouterPort mocks base method.
func (m *MockNbClient) CreateLogicalRouterPort(lrName, lrpName, mac string, networks []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLogicalRouterPort", lrName, lrpName, mac, networks)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateLogicalRouterPort indicates an expected call of CreateLogicalRouterPort.
func (mr *MockNbClientMockRecorder) CreateLogicalRouterPort(lrName, lrpName, mac, networks interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLogicalRouterPort", reflect.TypeOf((*MockNbClient)(nil).CreateLogicalRouterPort), lrName, lrpName, mac, networks)
}

// CreateLogicalSwitch mocks base method.
func (m *MockNbClient) CreateLogicalSwitch(lsName, lrName, cidrBlock, gateway string, needRouter, randomAllocateGW bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLogicalSwitch", lsName, lrName, cidrBlock, gateway, needRouter, randomAllocateGW)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateLogicalSwitch indicates an expected call of CreateLogicalSwitch.
func (mr *MockNbClientMockRecorder) CreateLogicalSwitch(lsName, lrName, cidrBlock, gateway, needRouter, randomAllocateGW interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLogicalSwitch", reflect.TypeOf((*MockNbClient)(nil).CreateLogicalSwitch), lsName, lrName, cidrBlock, gateway, needRouter, randomAllocateGW)
}

// CreateLogicalSwitchPort mocks base method.
func (m *MockNbClient) CreateLogicalSwitchPort(lsName, lspName, ip, mac, podName, namespace string, portSecurity bool, securityGroups, vips string, enableDHCP bool, dhcpOptions *ovs.DHCPOptionsUUIDs, vpc string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLogicalSwitchPort", lsName, lspName, ip, mac, podName, namespace, portSecurity, securityGroups, vips, enableDHCP, dhcpOptions, vpc)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateLogicalSwitchPort indicates an expected call of CreateLogicalSwitchPort.
func (mr *MockNbClientMockRecorder) CreateLogicalSwitchPort(lsName, lspName, ip, mac, podName, namespace, portSecurity, securityGroups, vips, enableDHCP, dhcpOptions, vpc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLogicalSwitchPort", reflect.TypeOf((*MockNbClient)(nil).CreateLogicalSwitchPort), lsName, lspName, ip, mac, podName, namespace, portSecurity, securityGroups, vips, enableDHCP, dhcpOptions, vpc)
}

// CreateNodeACL mocks base method.
func (m *MockNbClient) CreateNodeACL(pgName, nodeIPStr, joinIPStr string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNodeACL", pgName, nodeIPStr, joinIPStr)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateNodeACL indicates an expected call of CreateNodeACL.
func (mr *MockNbClientMockRecorder) CreateNodeACL(pgName, nodeIPStr, joinIPStr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNodeACL", reflect.TypeOf((*MockNbClient)(nil).CreateNodeACL), pgName, nodeIPStr, joinIPStr)
}

// CreatePeerRouterPort mocks base method.
func (m *MockNbClient) CreatePeerRouterPort(localRouter, remoteRouter, localRouterPortIP string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePeerRouterPort", localRouter, remoteRouter, localRouterPortIP)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreatePeerRouterPort indicates an expected call of CreatePeerRouterPort.
func (mr *MockNbClientMockRecorder) CreatePeerRouterPort(localRouter, remoteRouter, localRouterPortIP interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePeerRouterPort", reflect.TypeOf((*MockNbClient)(nil).CreatePeerRouterPort), localRouter, remoteRouter, localRouterPortIP)
}

// CreatePortGroup mocks base method.
func (m *MockNbClient) CreatePortGroup(pgName string, externalIDs map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePortGroup", pgName, externalIDs)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreatePortGroup indicates an expected call of CreatePortGroup.
func (mr *MockNbClientMockRecorder) CreatePortGroup(pgName, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePortGroup", reflect.TypeOf((*MockNbClient)(nil).CreatePortGroup), pgName, externalIDs)
}

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

// CreateSgBaseACL indicates an expected call of CreateSgBaseACL.
func (mr *MockNbClientMockRecorder) CreateSgBaseACL(sgName, direction interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSgBaseACL", reflect.TypeOf((*MockNbClient)(nil).CreateSgBaseACL), sgName, direction)
}

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

// CreateSgDenyAllACL indicates an expected call of CreateSgDenyAllACL.
func (mr *MockNbClientMockRecorder) CreateSgDenyAllACL(sgName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSgDenyAllACL", reflect.TypeOf((*MockNbClient)(nil).CreateSgDenyAllACL), sgName)
}

// CreateVirtualLogicalSwitchPorts mocks base method.
func (m *MockNbClient) CreateVirtualLogicalSwitchPorts(lsName string, ips ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{lsName}
	for _, a := range ips {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVirtualLogicalSwitchPorts", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateVirtualLogicalSwitchPorts indicates an expected call of CreateVirtualLogicalSwitchPorts.
func (mr *MockNbClientMockRecorder) CreateVirtualLogicalSwitchPorts(lsName interface{}, ips ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{lsName}, ips...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVirtualLogicalSwitchPorts", reflect.TypeOf((*MockNbClient)(nil).CreateVirtualLogicalSwitchPorts), varargs...)
}

// DeleteAcls mocks base method.
func (m *MockNbClient) DeleteAcls(parentName, parentType, direction string, externalIDs map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAcls", parentName, parentType, direction, externalIDs)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteAcls indicates an expected call of DeleteAcls.
func (mr *MockNbClientMockRecorder) DeleteAcls(parentName, parentType, direction, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAcls", reflect.TypeOf((*MockNbClient)(nil).DeleteAcls), parentName, parentType, direction, externalIDs)
}

// DeleteAclsOps mocks base method.
func (m *MockNbClient) DeleteAclsOps(parentName, parentType, direction string, externalIDs map[string]string) ([]ovsdb.Operation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAclsOps", parentName, parentType, direction, externalIDs)
	ret0, _ := ret[0].([]ovsdb.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAclsOps indicates an expected call of DeleteAclsOps.
func (mr *MockNbClientMockRecorder) DeleteAclsOps(parentName, parentType, direction, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAclsOps", reflect.TypeOf((*MockNbClient)(nil).DeleteAclsOps), parentName, parentType, direction, externalIDs)
}

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

// DeleteAddressSet indicates an expected call of DeleteAddressSet.
func (mr *MockNbClientMockRecorder) DeleteAddressSet(asName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAddressSet", reflect.TypeOf((*MockNbClient)(nil).DeleteAddressSet), asName)
}

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

// DeleteAddressSets indicates an expected call of DeleteAddressSets.
func (mr *MockNbClientMockRecorder) DeleteAddressSets(externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAddressSets", reflect.TypeOf((*MockNbClient)(nil).DeleteAddressSets), externalIDs)
}

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

// DeleteBFD indicates an expected call of DeleteBFD.
func (mr *MockNbClientMockRecorder) DeleteBFD(lrpName, dstIP interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBFD", reflect.TypeOf((*MockNbClient)(nil).DeleteBFD), lrpName, dstIP)
}

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

// DeleteDHCPOptions indicates an expected call of DeleteDHCPOptions.
func (mr *MockNbClientMockRecorder) DeleteDHCPOptions(lsName, protocol interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDHCPOptions", reflect.TypeOf((*MockNbClient)(nil).DeleteDHCPOptions), lsName, protocol)
}

// DeleteDHCPOptionsByUUIDs mocks base method.
func (m *MockNbClient) DeleteDHCPOptionsByUUIDs(uuidList ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range uuidList {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteDHCPOptionsByUUIDs", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDHCPOptionsByUUIDs indicates an expected call of DeleteDHCPOptionsByUUIDs.
func (mr *MockNbClientMockRecorder) DeleteDHCPOptionsByUUIDs(uuidList ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDHCPOptionsByUUIDs", reflect.TypeOf((*MockNbClient)(nil).DeleteDHCPOptionsByUUIDs), uuidList...)
}

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

// DeleteLoadBalancerHealthCheck indicates an expected call of DeleteLoadBalancerHealthCheck.
func (mr *MockNbClientMockRecorder) DeleteLoadBalancerHealthCheck(lbName, vip interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerHealthCheck", reflect.TypeOf((*MockNbClient)(nil).DeleteLoadBalancerHealthCheck), lbName, vip)
}

// DeleteLoadBalancerHealthChecks mocks base method.
func (m *MockNbClient) DeleteLoadBalancerHealthChecks(filter func(*ovnnb.LoadBalancerHealthCheck) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLoadBalancerHealthChecks", filter)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLoadBalancerHealthChecks indicates an expected call of DeleteLoadBalancerHealthChecks.
func (mr *MockNbClientMockRecorder) DeleteLoadBalancerHealthChecks(filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerHealthChecks", reflect.TypeOf((*MockNbClient)(nil).DeleteLoadBalancerHealthChecks), filter)
}

// DeleteLoadBalancers mocks base method.
func (m *MockNbClient) DeleteLoadBalancers(filter func(*ovnnb.LoadBalancer) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLoadBalancers", filter)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLoadBalancers indicates an expected call of DeleteLoadBalancers.
func (mr *MockNbClientMockRecorder) DeleteLoadBalancers(filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancers", reflect.TypeOf((*MockNbClient)(nil).DeleteLoadBalancers), filter)
}

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

// DeleteLogicalGatewaySwitch indicates an expected call of DeleteLogicalGatewaySwitch.
func (mr *MockNbClientMockRecorder) DeleteLogicalGatewaySwitch(lsName, lrName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalGatewaySwitch", reflect.TypeOf((*MockNbClient)(nil).DeleteLogicalGatewaySwitch), lsName, lrName)
}

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

// DeleteLogicalRouter indicates an expected call of DeleteLogicalRouter.
func (mr *MockNbClientMockRecorder) DeleteLogicalRouter(lrName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouter", reflect.TypeOf((*MockNbClient)(nil).DeleteLogicalRouter), lrName)
}

// DeleteLogicalRouterPolicies mocks base method.
func (m *MockNbClient) DeleteLogicalRouterPolicies(lrName string, priority int, externalIDs map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLogicalRouterPolicies", lrName, priority, externalIDs)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLogicalRouterPolicies indicates an expected call of DeleteLogicalRouterPolicies.
func (mr *MockNbClientMockRecorder) DeleteLogicalRouterPolicies(lrName, priority, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouterPolicies", reflect.TypeOf((*MockNbClient)(nil).DeleteLogicalRouterPolicies), lrName, priority, externalIDs)
}

// DeleteLogicalRouterPolicy mocks base method.
func (m *MockNbClient) DeleteLogicalRouterPolicy(lrName string, priority int, match string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLogicalRouterPolicy", lrName, priority, match)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLogicalRouterPolicy indicates an expected call of DeleteLogicalRouterPolicy.
func (mr *MockNbClientMockRecorder) DeleteLogicalRouterPolicy(lrName, priority, match interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouterPolicy", reflect.TypeOf((*MockNbClient)(nil).DeleteLogicalRouterPolicy), lrName, priority, match)
}

// DeleteLogicalRouterPolicyByNexthop mocks base method.
func (m *MockNbClient) DeleteLogicalRouterPolicyByNexthop(lrName string, priority int, nexthop string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLogicalRouterPolicyByNexthop", lrName, priority, nexthop)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLogicalRouterPolicyByNexthop indicates an expected call of DeleteLogicalRouterPolicyByNexthop.
func (mr *MockNbClientMockRecorder) DeleteLogicalRouterPolicyByNexthop(lrName, priority, nexthop interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouterPolicyByNexthop", reflect.TypeOf((*MockNbClient)(nil).DeleteLogicalRouterPolicyByNexthop), lrName, priority, nexthop)
}

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

// DeleteLogicalRouterPolicyByUUID indicates an expected call of DeleteLogicalRouterPolicyByUUID.
func (mr *MockNbClientMockRecorder) DeleteLogicalRouterPolicyByUUID(lrName, uuid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouterPolicyByUUID", reflect.TypeOf((*MockNbClient)(nil).DeleteLogicalRouterPolicyByUUID), lrName, uuid)
}

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

// DeleteLogicalRouterPort indicates an expected call of DeleteLogicalRouterPort.
func (mr *MockNbClientMockRecorder) DeleteLogicalRouterPort(lrpName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouterPort", reflect.TypeOf((*MockNbClient)(nil).DeleteLogicalRouterPort), lrpName)
}

// DeleteLogicalRouterPorts mocks base method.
func (m *MockNbClient) DeleteLogicalRouterPorts(externalIDs map[string]string, filter func(*ovnnb.LogicalRouterPort) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLogicalRouterPorts", externalIDs, filter)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLogicalRouterPorts indicates an expected call of DeleteLogicalRouterPorts.
func (mr *MockNbClientMockRecorder) DeleteLogicalRouterPorts(externalIDs, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouterPorts", reflect.TypeOf((*MockNbClient)(nil).DeleteLogicalRouterPorts), externalIDs, filter)
}

// DeleteLogicalRouterStaticRoute mocks base method.
func (m *MockNbClient) DeleteLogicalRouterStaticRoute(lrName string, routeTable, policy *string, ipPrefix, nextHop string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLogicalRouterStaticRoute", lrName, routeTable, policy, ipPrefix, nextHop)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLogicalRouterStaticRoute indicates an expected call of DeleteLogicalRouterStaticRoute.
func (mr *MockNbClientMockRecorder) DeleteLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix, nextHop interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalRouterStaticRoute", reflect.TypeOf((*MockNbClient)(nil).DeleteLogicalRouterStaticRoute), lrName, routeTable, policy, ipPrefix, nextHop)
}

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

// DeleteLogicalSwitch indicates an expected call of DeleteLogicalSwitch.
func (mr *MockNbClientMockRecorder) DeleteLogicalSwitch(lsName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalSwitch", reflect.TypeOf((*MockNbClient)(nil).DeleteLogicalSwitch), lsName)
}

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

// DeleteLogicalSwitchPort indicates an expected call of DeleteLogicalSwitchPort.
func (mr *MockNbClientMockRecorder) DeleteLogicalSwitchPort(lspName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalSwitchPort", reflect.TypeOf((*MockNbClient)(nil).DeleteLogicalSwitchPort), lspName)
}

// DeleteLogicalSwitchPorts mocks base method.
func (m *MockNbClient) DeleteLogicalSwitchPorts(externalIDs map[string]string, filter func(*ovnnb.LogicalSwitchPort) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLogicalSwitchPorts", externalIDs, filter)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLogicalSwitchPorts indicates an expected call of DeleteLogicalSwitchPorts.
func (mr *MockNbClientMockRecorder) DeleteLogicalSwitchPorts(externalIDs, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogicalSwitchPorts", reflect.TypeOf((*MockNbClient)(nil).DeleteLogicalSwitchPorts), externalIDs, filter)
}

// DeleteNat mocks base method.
func (m *MockNbClient) DeleteNat(lrName, natType, externalIP, logicalIP string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNat", lrName, natType, externalIP, logicalIP)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNat indicates an expected call of DeleteNat.
func (mr *MockNbClientMockRecorder) DeleteNat(lrName, natType, externalIP, logicalIP interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNat", reflect.TypeOf((*MockNbClient)(nil).DeleteNat), lrName, natType, externalIP, logicalIP)
}

// DeleteNats mocks base method.
func (m *MockNbClient) DeleteNats(lrName, natType, logicalIP string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNats", lrName, natType, logicalIP)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNats indicates an expected call of DeleteNats.
func (mr *MockNbClientMockRecorder) DeleteNats(lrName, natType, logicalIP interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNats", reflect.TypeOf((*MockNbClient)(nil).DeleteNats), lrName, natType, logicalIP)
}

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

// DeletePortGroup indicates an expected call of DeletePortGroup.
func (mr *MockNbClientMockRecorder) DeletePortGroup(pgName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePortGroup", reflect.TypeOf((*MockNbClient)(nil).DeletePortGroup), pgName)
}

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

// DeleteSecurityGroup indicates an expected call of DeleteSecurityGroup.
func (mr *MockNbClientMockRecorder) DeleteSecurityGroup(sgName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroup", reflect.TypeOf((*MockNbClient)(nil).DeleteSecurityGroup), sgName)
}

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

// EnablePortLayer2forward indicates an expected call of EnablePortLayer2forward.
func (mr *MockNbClientMockRecorder) EnablePortLayer2forward(lspName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnablePortLayer2forward", reflect.TypeOf((*MockNbClient)(nil).EnablePortLayer2forward), lspName)
}

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

// GetEntityInfo indicates an expected call of GetEntityInfo.
func (mr *MockNbClientMockRecorder) GetEntityInfo(entity interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEntityInfo", reflect.TypeOf((*MockNbClient)(nil).GetEntityInfo), entity)
}

// GetLoadBalancer mocks base method.
func (m *MockNbClient) GetLoadBalancer(lbName string, ignoreNotFound bool) (*ovnnb.LoadBalancer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLoadBalancer", lbName, ignoreNotFound)
	ret0, _ := ret[0].(*ovnnb.LoadBalancer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLoadBalancer indicates an expected call of GetLoadBalancer.
func (mr *MockNbClientMockRecorder) GetLoadBalancer(lbName, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancer", reflect.TypeOf((*MockNbClient)(nil).GetLoadBalancer), lbName, ignoreNotFound)
}

// GetLoadBalancerHealthCheck mocks base method.
func (m *MockNbClient) GetLoadBalancerHealthCheck(lbName, vip string, ignoreNotFound bool) (*ovnnb.LoadBalancer, *ovnnb.LoadBalancerHealthCheck, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLoadBalancerHealthCheck", lbName, vip, ignoreNotFound)
	ret0, _ := ret[0].(*ovnnb.LoadBalancer)
	ret1, _ := ret[1].(*ovnnb.LoadBalancerHealthCheck)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetLoadBalancerHealthCheck indicates an expected call of GetLoadBalancerHealthCheck.
func (mr *MockNbClientMockRecorder) GetLoadBalancerHealthCheck(lbName, vip, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancerHealthCheck", reflect.TypeOf((*MockNbClient)(nil).GetLoadBalancerHealthCheck), lbName, vip, ignoreNotFound)
}

// GetLogicalRouter mocks base method.
func (m *MockNbClient) GetLogicalRouter(lrName string, ignoreNotFound bool) (*ovnnb.LogicalRouter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogicalRouter", lrName, ignoreNotFound)
	ret0, _ := ret[0].(*ovnnb.LogicalRouter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogicalRouter indicates an expected call of GetLogicalRouter.
func (mr *MockNbClientMockRecorder) GetLogicalRouter(lrName, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogicalRouter", reflect.TypeOf((*MockNbClient)(nil).GetLogicalRouter), lrName, ignoreNotFound)
}

// GetLogicalRouterPoliciesByExtID mocks base method.
func (m *MockNbClient) GetLogicalRouterPoliciesByExtID(lrName, key, value string) ([]*ovnnb.LogicalRouterPolicy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogicalRouterPoliciesByExtID", lrName, key, value)
	ret0, _ := ret[0].([]*ovnnb.LogicalRouterPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogicalRouterPoliciesByExtID indicates an expected call of GetLogicalRouterPoliciesByExtID.
func (mr *MockNbClientMockRecorder) GetLogicalRouterPoliciesByExtID(lrName, key, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogicalRouterPoliciesByExtID", reflect.TypeOf((*MockNbClient)(nil).GetLogicalRouterPoliciesByExtID), lrName, key, value)
}

// GetLogicalRouterPolicy mocks base method.
func (m *MockNbClient) GetLogicalRouterPolicy(lrName string, priority int, match string, ignoreNotFound bool) ([]*ovnnb.LogicalRouterPolicy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogicalRouterPolicy", lrName, priority, match, ignoreNotFound)
	ret0, _ := ret[0].([]*ovnnb.LogicalRouterPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogicalRouterPolicy indicates an expected call of GetLogicalRouterPolicy.
func (mr *MockNbClientMockRecorder) GetLogicalRouterPolicy(lrName, priority, match, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogicalRouterPolicy", reflect.TypeOf((*MockNbClient)(nil).GetLogicalRouterPolicy), lrName, priority, match, ignoreNotFound)
}

// GetLogicalRouterPort mocks base method.
func (m *MockNbClient) GetLogicalRouterPort(lrpName string, ignoreNotFound bool) (*ovnnb.LogicalRouterPort, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogicalRouterPort", lrpName, ignoreNotFound)
	ret0, _ := ret[0].(*ovnnb.LogicalRouterPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogicalRouterPort indicates an expected call of GetLogicalRouterPort.
func (mr *MockNbClientMockRecorder) GetLogicalRouterPort(lrpName, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogicalRouterPort", reflect.TypeOf((*MockNbClient)(nil).GetLogicalRouterPort), lrpName, ignoreNotFound)
}

// GetLogicalRouterPortByUUID mocks base method.
func (m *MockNbClient) GetLogicalRouterPortByUUID(uuid string) (*ovnnb.LogicalRouterPort, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogicalRouterPortByUUID", uuid)
	ret0, _ := ret[0].(*ovnnb.LogicalRouterPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogicalRouterPortByUUID indicates an expected call of GetLogicalRouterPortByUUID.
func (mr *MockNbClientMockRecorder) GetLogicalRouterPortByUUID(uuid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogicalRouterPortByUUID", reflect.TypeOf((*MockNbClient)(nil).GetLogicalRouterPortByUUID), uuid)
}

// GetLogicalSwitchPort mocks base method.
func (m *MockNbClient) GetLogicalSwitchPort(lspName string, ignoreNotFound bool) (*ovnnb.LogicalSwitchPort, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogicalSwitchPort", lspName, ignoreNotFound)
	ret0, _ := ret[0].(*ovnnb.LogicalSwitchPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogicalSwitchPort indicates an expected call of GetLogicalSwitchPort.
func (mr *MockNbClientMockRecorder) GetLogicalSwitchPort(lspName, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogicalSwitchPort", reflect.TypeOf((*MockNbClient)(nil).GetLogicalSwitchPort), lspName, ignoreNotFound)
}

// GetNATByUUID mocks base method.
func (m *MockNbClient) GetNATByUUID(uuid string) (*ovnnb.NAT, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNATByUUID", uuid)
	ret0, _ := ret[0].(*ovnnb.NAT)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNATByUUID indicates an expected call of GetNATByUUID.
func (mr *MockNbClientMockRecorder) GetNATByUUID(uuid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNATByUUID", reflect.TypeOf((*MockNbClient)(nil).GetNATByUUID), uuid)
}

// GetNbGlobal mocks base method.
func (m *MockNbClient) GetNbGlobal() (*ovnnb.NBGlobal, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNbGlobal")
	ret0, _ := ret[0].(*ovnnb.NBGlobal)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPortGroup mocks base method.
func (m *MockNbClient) GetPortGroup(pgName string, ignoreNotFound bool) (*ovnnb.PortGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPortGroup", pgName, ignoreNotFound)
	ret0, _ := ret[0].(*ovnnb.PortGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPortGroup indicates an expected call of GetPortGroup.
func (mr *MockNbClientMockRecorder) GetPortGroup(pgName, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPortGroup", reflect.TypeOf((*MockNbClient)(nil).GetPortGroup), pgName, ignoreNotFound)
}

// ListAddressSets mocks base method.
func (m *MockNbClient) ListAddressSets(externalIDs map[string]string) ([]ovnnb.AddressSet, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAddressSets", externalIDs)
	ret0, _ := ret[0].([]ovnnb.AddressSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAddressSets indicates an expected call of ListAddressSets.
func (mr *MockNbClientMockRecorder) ListAddressSets(externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAddressSets", reflect.TypeOf((*MockNbClient)(nil).ListAddressSets), externalIDs)
}

// ListDHCPOptions mocks base method.
func (m *MockNbClient) ListDHCPOptions(needVendorFilter bool, externalIDs map[string]string) ([]ovnnb.DHCPOptions, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDHCPOptions", needVendorFilter, externalIDs)
	ret0, _ := ret[0].([]ovnnb.DHCPOptions)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDHCPOptions indicates an expected call of ListDHCPOptions.
func (mr *MockNbClientMockRecorder) ListDHCPOptions(needVendorFilter, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDHCPOptions", reflect.TypeOf((*MockNbClient)(nil).ListDHCPOptions), needVendorFilter, externalIDs)
}

// ListLoadBalancerHealthChecks mocks base method.
func (m *MockNbClient) ListLoadBalancerHealthChecks(filter func(*ovnnb.LoadBalancerHealthCheck) bool) ([]ovnnb.LoadBalancerHealthCheck, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLoadBalancerHealthChecks", filter)
	ret0, _ := ret[0].([]ovnnb.LoadBalancerHealthCheck)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLoadBalancerHealthChecks indicates an expected call of ListLoadBalancerHealthChecks.
func (mr *MockNbClientMockRecorder) ListLoadBalancerHealthChecks(filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLoadBalancerHealthChecks", reflect.TypeOf((*MockNbClient)(nil).ListLoadBalancerHealthChecks), filter)
}

// ListLoadBalancers mocks base method.
func (m *MockNbClient) ListLoadBalancers(filter func(*ovnnb.LoadBalancer) bool) ([]ovnnb.LoadBalancer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLoadBalancers", filter)
	ret0, _ := ret[0].([]ovnnb.LoadBalancer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLoadBalancers indicates an expected call of ListLoadBalancers.
func (mr *MockNbClientMockRecorder) ListLoadBalancers(filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLoadBalancers", reflect.TypeOf((*MockNbClient)(nil).ListLoadBalancers), filter)
}

// ListLogicalRouter mocks base method.
func (m *MockNbClient) ListLogicalRouter(needVendorFilter bool, filter func(*ovnnb.LogicalRouter) bool) ([]ovnnb.LogicalRouter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalRouter", needVendorFilter, filter)
	ret0, _ := ret[0].([]ovnnb.LogicalRouter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogicalRouter indicates an expected call of ListLogicalRouter.
func (mr *MockNbClientMockRecorder) ListLogicalRouter(needVendorFilter, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogicalRouter", reflect.TypeOf((*MockNbClient)(nil).ListLogicalRouter), needVendorFilter, filter)
}

// ListLogicalRouterPolicies mocks base method.
func (m *MockNbClient) ListLogicalRouterPolicies(lrName string, priority int, externalIDs map[string]string, ignoreExtIDEmptyValue bool) ([]*ovnnb.LogicalRouterPolicy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalRouterPolicies", lrName, priority, externalIDs, ignoreExtIDEmptyValue)
	ret0, _ := ret[0].([]*ovnnb.LogicalRouterPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogicalRouterPolicies indicates an expected call of ListLogicalRouterPolicies.
func (mr *MockNbClientMockRecorder) ListLogicalRouterPolicies(lrName, priority, externalIDs, ignoreExtIDEmptyValue interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogicalRouterPolicies", reflect.TypeOf((*MockNbClient)(nil).ListLogicalRouterPolicies), lrName, priority, externalIDs, ignoreExtIDEmptyValue)
}

// ListLogicalRouterPorts mocks base method.
func (m *MockNbClient) ListLogicalRouterPorts(externalIDs map[string]string, filter func(*ovnnb.LogicalRouterPort) bool) ([]ovnnb.LogicalRouterPort, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalRouterPorts", externalIDs, filter)
	ret0, _ := ret[0].([]ovnnb.LogicalRouterPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogicalRouterPorts indicates an expected call of ListLogicalRouterPorts.
func (mr *MockNbClientMockRecorder) ListLogicalRouterPorts(externalIDs, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogicalRouterPorts", reflect.TypeOf((*MockNbClient)(nil).ListLogicalRouterPorts), externalIDs, filter)
}

// ListLogicalRouterStaticRoutes mocks base method.
func (m *MockNbClient) ListLogicalRouterStaticRoutes(lrName string, routeTable, policy *string, ipPrefix string, externalIDs map[string]string) ([]*ovnnb.LogicalRouterStaticRoute, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalRouterStaticRoutes", lrName, routeTable, policy, ipPrefix, externalIDs)
	ret0, _ := ret[0].([]*ovnnb.LogicalRouterStaticRoute)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogicalRouterStaticRoutes indicates an expected call of ListLogicalRouterStaticRoutes.
func (mr *MockNbClientMockRecorder) ListLogicalRouterStaticRoutes(lrName, routeTable, policy, ipPrefix, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogicalRouterStaticRoutes", reflect.TypeOf((*MockNbClient)(nil).ListLogicalRouterStaticRoutes), lrName, routeTable, policy, ipPrefix, externalIDs)
}

// ListLogicalRouterStaticRoutesByOption mocks base method.
func (m *MockNbClient) ListLogicalRouterStaticRoutesByOption(lrName, routeTable, key, value string) ([]*ovnnb.LogicalRouterStaticRoute, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalRouterStaticRoutesByOption", lrName, routeTable, key, value)
	ret0, _ := ret[0].([]*ovnnb.LogicalRouterStaticRoute)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogicalRouterStaticRoutesByOption indicates an expected call of ListLogicalRouterStaticRoutesByOption.
func (mr *MockNbClientMockRecorder) ListLogicalRouterStaticRoutesByOption(lrName, routeTable, key, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogicalRouterStaticRoutesByOption", reflect.TypeOf((*MockNbClient)(nil).ListLogicalRouterStaticRoutesByOption), lrName, routeTable, key, value)
}

// ListLogicalSwitch mocks base method.
func (m *MockNbClient) ListLogicalSwitch(needVendorFilter bool, filter func(*ovnnb.LogicalSwitch) bool) ([]ovnnb.LogicalSwitch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalSwitch", needVendorFilter, filter)
	ret0, _ := ret[0].([]ovnnb.LogicalSwitch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogicalSwitch indicates an expected call of ListLogicalSwitch.
func (mr *MockNbClientMockRecorder) ListLogicalSwitch(needVendorFilter, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogicalSwitch", reflect.TypeOf((*MockNbClient)(nil).ListLogicalSwitch), needVendorFilter, filter)
}

// ListLogicalSwitchPorts mocks base method.
func (m *MockNbClient) ListLogicalSwitchPorts(needVendorFilter bool, externalIDs map[string]string, filter func(*ovnnb.LogicalSwitchPort) bool) ([]ovnnb.LogicalSwitchPort, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalSwitchPorts", needVendorFilter, externalIDs, filter)
	ret0, _ := ret[0].([]ovnnb.LogicalSwitchPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogicalSwitchPorts indicates an expected call of ListLogicalSwitchPorts.
func (mr *MockNbClientMockRecorder) ListLogicalSwitchPorts(needVendorFilter, externalIDs, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogicalSwitchPorts", reflect.TypeOf((*MockNbClient)(nil).ListLogicalSwitchPorts), needVendorFilter, externalIDs, filter)
}

// ListLogicalSwitchPortsWithLegacyExternalIDs mocks base method.
func (m *MockNbClient) ListLogicalSwitchPortsWithLegacyExternalIDs() ([]ovnnb.LogicalSwitchPort, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogicalSwitchPortsWithLegacyExternalIDs")
	ret0, _ := ret[0].([]ovnnb.LogicalSwitchPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNats mocks base method.
func (m *MockNbClient) ListNats(lrName, natType, logicalIP string, externalIDs map[string]string) ([]*ovnnb.NAT, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNats", lrName, natType, logicalIP, externalIDs)
	ret0, _ := ret[0].([]*ovnnb.NAT)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNats indicates an expected call of ListNats.
func (mr *MockNbClientMockRecorder) ListNats(lrName, natType, logicalIP, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNats", reflect.TypeOf((*MockNbClient)(nil).ListNats), lrName, natType, logicalIP, externalIDs)
}

// ListNormalLogicalSwitchPorts mocks base method.
func (m *MockNbClient) ListNormalLogicalSwitchPorts(needVendorFilter bool, externalIDs map[string]string) ([]ovnnb.LogicalSwitchPort, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNormalLogicalSwitchPorts", needVendorFilter, externalIDs)
	ret0, _ := ret[0].([]ovnnb.LogicalSwitchPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNormalLogicalSwitchPorts indicates an expected call of ListNormalLogicalSwitchPorts.
func (mr *MockNbClientMockRecorder) ListNormalLogicalSwitchPorts(needVendorFilter, externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNormalLogicalSwitchPorts", reflect.TypeOf((*MockNbClient)(nil).ListNormalLogicalSwitchPorts), needVendorFilter, externalIDs)
}

// ListPortGroups mocks base method.
func (m *MockNbClient) ListPortGroups(externalIDs map[string]string) ([]ovnnb.PortGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPortGroups", externalIDs)
	ret0, _ := ret[0].([]ovnnb.PortGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPortGroups indicates an expected call of ListPortGroups.
func (mr *MockNbClientMockRecorder) ListPortGroups(externalIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPortGroups", reflect.TypeOf((*MockNbClient)(nil).ListPortGroups), externalIDs)
}

// LoadBalancerAddHealthCheck mocks base method.
func (m *MockNbClient) LoadBalancerAddHealthCheck(lbName, vip string, ignoreHealthCheck bool, ipPortMapping, externals map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancerAddHealthCheck", lbName, vip, ignoreHealthCheck, ipPortMapping, externals)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadBalancerAddHealthCheck indicates an expected call of LoadBalancerAddHealthCheck.
func (mr *MockNbClientMockRecorder) LoadBalancerAddHealthCheck(lbName, vip, ignoreHealthCheck, ipPortMapping, externals interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerAddHealthCheck", reflect.TypeOf((*MockNbClient)(nil).LoadBalancerAddHealthCheck), lbName, vip, ignoreHealthCheck, ipPortMapping, externals)
}

// LoadBalancerAddIPPortMapping mocks base method.
func (m *MockNbClient) LoadBalancerAddIPPortMapping(lbName, vip string, ipPortMappings map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancerAddIPPortMapping", lbName, vip, ipPortMappings)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadBalancerAddIPPortMapping indicates an expected call of LoadBalancerAddIPPortMapping.
func (mr *MockNbClientMockRecorder) LoadBalancerAddIPPortMapping(lbName, vip, ipPortMappings interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerAddIPPortMapping", reflect.TypeOf((*MockNbClient)(nil).LoadBalancerAddIPPortMapping), lbName, vip, ipPortMappings)
}

// LoadBalancerAddVip mocks base method.
func (m *MockNbClient) LoadBalancerAddVip(lbName, vip string, backends ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{lbName, vip}
	for _, a := range backends {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LoadBalancerAddVip", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadBalancerAddVip indicates an expected call of LoadBalancerAddVip.
func (mr *MockNbClientMockRecorder) LoadBalancerAddVip(lbName, vip interface{}, backends ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{lbName, vip}, backends...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerAddVip", reflect.TypeOf((*MockNbClient)(nil).LoadBalancerAddVip), varargs...)
}

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

// LoadBalancerDeleteHealthCheck indicates an expected call of LoadBalancerDeleteHealthCheck.
func (mr *MockNbClientMockRecorder) LoadBalancerDeleteHealthCheck(lbName, uuid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerDeleteHealthCheck", reflect.TypeOf((*MockNbClient)(nil).LoadBalancerDeleteHealthCheck), lbName, uuid)
}

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

// LoadBalancerDeleteIPPortMapping indicates an expected call of LoadBalancerDeleteIPPortMapping.
func (mr *MockNbClientMockRecorder) LoadBalancerDeleteIPPortMapping(lbName, vip interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerDeleteIPPortMapping", reflect.TypeOf((*MockNbClient)(nil).LoadBalancerDeleteIPPortMapping), lbName, vip)
}

// LoadBalancerDeleteVip mocks base method.
func (m *MockNbClient) LoadBalancerDeleteVip(lbName, vip string, ignoreHealthCheck bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancerDeleteVip", lbName, vip, ignoreHealthCheck)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadBalancerDeleteVip indicates an expected call of LoadBalancerDeleteVip.
func (mr *MockNbClientMockRecorder) LoadBalancerDeleteVip(lbName, vip, ignoreHealthCheck interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerDeleteVip", reflect.TypeOf((*MockNbClient)(nil).LoadBalancerDeleteVip), lbName, vip, ignoreHealthCheck)
}

// LoadBalancerExists mocks base method.
func (m *MockNbClient) LoadBalancerExists(lbName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancerExists", lbName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadBalancerExists indicates an expected call of LoadBalancerExists.
func (mr *MockNbClientMockRecorder) LoadBalancerExists(lbName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerExists", reflect.TypeOf((*MockNbClient)(nil).LoadBalancerExists), lbName)
}

// LoadBalancerHealthCheckExists mocks base method.
func (m *MockNbClient) LoadBalancerHealthCheckExists(lbName, vip string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancerHealthCheckExists", lbName, vip)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadBalancerHealthCheckExists indicates an expected call of LoadBalancerHealthCheckExists.
func (mr *MockNbClientMockRecorder) LoadBalancerHealthCheckExists(lbName, vip interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerHealthCheckExists", reflect.TypeOf((*MockNbClient)(nil).LoadBalancerHealthCheckExists), lbName, vip)
}

// LoadBalancerUpdateIPPortMapping mocks base method.
func (m *MockNbClient) LoadBalancerUpdateIPPortMapping(lbName, vip string, ipPortMappings map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancerUpdateIPPortMapping", lbName, vip, ipPortMappings)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadBalancerUpdateIPPortMapping indicates an expected call of LoadBalancerUpdateIPPortMapping.
func (mr *MockNbClientMockRecorder) LoadBalancerUpdateIPPortMapping(lbName, vip, ipPortMappings interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerUpdateIPPortMapping", reflect.TypeOf((*MockNbClient)(nil).LoadBalancerUpdateIPPortMapping), lbName, vip, ipPortMappings)
}

// LogicalRouterExists mocks base method.
func (m *MockNbClient) LogicalRouterExists(name string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogicalRouterExists", name)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogicalRouterExists indicates an expected call of LogicalRouterExists.
func (mr *MockNbClientMockRecorder) LogicalRouterExists(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogicalRouterExists", reflect.TypeOf((*MockNbClient)(nil).LogicalRouterExists), name)
}

// LogicalRouterPortExists mocks base method.
func (m *MockNbClient) LogicalRouterPortExists(lrpName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogicalRouterPortExists", lrpName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogicalRouterPortExists indicates an expected call of LogicalRouterPortExists.
func (mr *MockNbClientMockRecorder) LogicalRouterPortExists(lrpName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogicalRouterPortExists", reflect.TypeOf((*MockNbClient)(nil).LogicalRouterPortExists), lrpName)
}

// LogicalRouterStaticRouteExists mocks base method.
func (m *MockNbClient) LogicalRouterStaticRouteExists(lrName, routeTable, policy, ipPrefix, nexthop string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogicalRouterStaticRouteExists", lrName, routeTable, policy, ipPrefix, nexthop)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogicalRouterStaticRouteExists indicates an expected call of LogicalRouterStaticRouteExists.
func (mr *MockNbClientMockRecorder) LogicalRouterStaticRouteExists(lrName, routeTable, policy, ipPrefix, nexthop interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogicalRouterStaticRouteExists", reflect.TypeOf((*MockNbClient)(nil).LogicalRouterStaticRouteExists), lrName, routeTable, policy, ipPrefix, nexthop)
}

// LogicalRouterUpdateLoadBalancers mocks base method.
func (m *MockNbClient) LogicalRouterUpdateLoadBalancers(lrName string, op ovsdb.Mutator, lbNames ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{lrName, op}
	for _, a := range lbNames {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LogicalRouterUpdateLoadBalancers", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// LogicalRouterUpdateLoadBalancers indicates an expected call of LogicalRouterUpdateLoadBalancers.
func (mr *MockNbClientMockRecorder) LogicalRouterUpdateLoadBalancers(lrName, op interface{}, lbNames ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{lrName, op}, lbNames...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogicalRouterUpdateLoadBalancers", reflect.TypeOf((*MockNbClient)(nil).LogicalRouterUpdateLoadBalancers), varargs...)
}

// LogicalSwitchExists mocks base method.
func (m *MockNbClient) LogicalSwitchExists(lsName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogicalSwitchExists", lsName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogicalSwitchExists indicates an expected call of LogicalSwitchExists.
func (mr *MockNbClientMockRecorder) LogicalSwitchExists(lsName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogicalSwitchExists", reflect.TypeOf((*MockNbClient)(nil).LogicalSwitchExists), lsName)
}

// LogicalSwitchPortExists mocks base method.
func (m *MockNbClient) LogicalSwitchPortExists(name string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LogicalSwitchPortExists", name)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LogicalSwitchPortExists indicates an expected call of LogicalSwitchPortExists.
func (mr *MockNbClientMockRecorder) LogicalSwitchPortExists(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogicalSwitchPortExists", reflect.TypeOf((*MockNbClient)(nil).LogicalSwitchPortExists), name)
}

// LogicalSwitchUpdateLoadBalancers mocks base method.
func (m *MockNbClient) LogicalSwitchUpdateLoadBalancers(lsName string, op ovsdb.Mutator, lbNames ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{lsName, op}
	for _, a := range lbNames {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LogicalSwitchUpdateLoadBalancers", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// LogicalSwitchUpdateLoadBalancers indicates an expected call of LogicalSwitchUpdateLoadBalancers.
func (mr *MockNbClientMockRecorder) LogicalSwitchUpdateLoadBalancers(lsName, op interface{}, lbNames ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{lsName, op}, lbNames...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogicalSwitchUpdateLoadBalancers", reflect.TypeOf((*MockNbClient)(nil).LogicalSwitchUpdateLoadBalancers), varargs...)
}

// NatExists mocks base method.
func (m *MockNbClient) NatExists(lrName, natType, externalIP, logicalIP string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NatExists", lrName, natType, externalIP, logicalIP)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NatExists indicates an expected call of NatExists.
func (mr *MockNbClientMockRecorder) NatExists(lrName, natType, externalIP, logicalIP interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NatExists", reflect.TypeOf((*MockNbClient)(nil).NatExists), lrName, natType, externalIP, logicalIP)
}

// PortGroupAddPorts mocks base method.
func (m *MockNbClient) PortGroupAddPorts(pgName string, lspNames ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{pgName}
	for _, a := range lspNames {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PortGroupAddPorts", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// PortGroupAddPorts indicates an expected call of PortGroupAddPorts.
func (mr *MockNbClientMockRecorder) PortGroupAddPorts(pgName interface{}, lspNames ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{pgName}, lspNames...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PortGroupAddPorts", reflect.TypeOf((*MockNbClient)(nil).PortGroupAddPorts), varargs...)
}

// PortGroupExists mocks base method.
func (m *MockNbClient) PortGroupExists(pgName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PortGroupExists", pgName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PortGroupExists indicates an expected call of PortGroupExists.
func (mr *MockNbClientMockRecorder) PortGroupExists(pgName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PortGroupExists", reflect.TypeOf((*MockNbClient)(nil).PortGroupExists), pgName)
}

// PortGroupRemovePorts mocks base method.
func (m *MockNbClient) PortGroupRemovePorts(pgName string, lspNames ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{pgName}
	for _, a := range lspNames {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PortGroupRemovePorts", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// PortGroupRemovePorts indicates an expected call of PortGroupRemovePorts.
func (mr *MockNbClientMockRecorder) PortGroupRemovePorts(pgName interface{}, lspNames ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{pgName}, lspNames...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PortGroupRemovePorts", reflect.TypeOf((*MockNbClient)(nil).PortGroupRemovePorts), varargs...)
}

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

// PortGroupSetPorts indicates an expected call of PortGroupSetPorts.
func (mr *MockNbClientMockRecorder) PortGroupSetPorts(pgName, ports interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PortGroupSetPorts", reflect.TypeOf((*MockNbClient)(nil).PortGroupSetPorts), pgName, ports)
}

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

// RemoveLogicalPatchPort indicates an expected call of RemoveLogicalPatchPort.
func (mr *MockNbClientMockRecorder) RemoveLogicalPatchPort(lspName, lrpName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveLogicalPatchPort", reflect.TypeOf((*MockNbClient)(nil).RemoveLogicalPatchPort), lspName, lrpName)
}

// SetACLLog mocks base method.
func (m *MockNbClient) SetACLLog(pgName, protocol string, logEnable, isIngress bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetACLLog", pgName, protocol, logEnable, isIngress)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetACLLog indicates an expected call of SetACLLog.
func (mr *MockNbClientMockRecorder) SetACLLog(pgName, protocol, logEnable, isIngress interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetACLLog", reflect.TypeOf((*MockNbClient)(nil).SetACLLog), pgName, protocol, logEnable, isIngress)
}

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

// SetAzName indicates an expected call of SetAzName.
func (mr *MockNbClientMockRecorder) SetAzName(azName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAzName", reflect.TypeOf((*MockNbClient)(nil).SetAzName), azName)
}

// SetICAutoRoute mocks base method.
func (m *MockNbClient) SetICAutoRoute(enable bool, blackList []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetICAutoRoute", enable, blackList)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetICAutoRoute indicates an expected call of SetICAutoRoute.
func (mr *MockNbClientMockRecorder) SetICAutoRoute(enable, blackList interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetICAutoRoute", reflect.TypeOf((*MockNbClient)(nil).SetICAutoRoute), enable, blackList)
}

// SetLoadBalancerAffinityTimeout mocks base method.
func (m *MockNbClient) SetLoadBalancerAffinityTimeout(lbName string, timeout int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLoadBalancerAffinityTimeout", lbName, timeout)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLoadBalancerAffinityTimeout indicates an expected call of SetLoadBalancerAffinityTimeout.
func (mr *MockNbClientMockRecorder) SetLoadBalancerAffinityTimeout(lbName, timeout interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerAffinityTimeout", reflect.TypeOf((*MockNbClient)(nil).SetLoadBalancerAffinityTimeout), lbName, timeout)
}

// SetLogicalSwitchPortArpProxy mocks base method.
func (m *MockNbClient) SetLogicalSwitchPortArpProxy(lspName string, enableArpProxy bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLogicalSwitchPortArpProxy", lspName, enableArpProxy)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLogicalSwitchPortArpProxy indicates an expected call of SetLogicalSwitchPortArpProxy.
func (mr *MockNbClientMockRecorder) SetLogicalSwitchPortArpProxy(lspName, enableArpProxy interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogicalSwitchPortArpProxy", reflect.TypeOf((*MockNbClient)(nil).SetLogicalSwitchPortArpProxy), lspName, enableArpProxy)
}

// SetLogicalSwitchPortExternalIds mocks base method.
func (m *MockNbClient) SetLogicalSwitchPortExternalIds(lspName string, externalIds map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLogicalSwitchPortExternalIds", lspName, externalIds)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLogicalSwitchPortExternalIds indicates an expected call of SetLogicalSwitchPortExternalIds.
func (mr *MockNbClientMockRecorder) SetLogicalSwitchPortExternalIds(lspName, externalIds interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogicalSwitchPortExternalIds", reflect.TypeOf((*MockNbClient)(nil).SetLogicalSwitchPortExternalIds), lspName, externalIds)
}

// SetLogicalSwitchPortSecurity mocks base method.
func (m *MockNbClient) SetLogicalSwitchPortSecurity(portSecurity bool, lspName, mac, ips, vips string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLogicalSwitchPortSecurity", portSecurity, lspName, mac, ips, vips)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLogicalSwitchPortSecurity indicates an expected call of SetLogicalSwitchPortSecurity.
func (mr *MockNbClientMockRecorder) SetLogicalSwitchPortSecurity(portSecurity, lspName, mac, ips, vips interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogicalSwitchPortSecurity", reflect.TypeOf((*MockNbClient)(nil).SetLogicalSwitchPortSecurity), portSecurity, lspName, mac, ips, vips)
}

// SetLogicalSwitchPortVirtualParents mocks base method.
func (m *MockNbClient) SetLogicalSwitchPortVirtualParents(lsName, parents string, ips ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{lsName, parents}
	for _, a := range ips {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetLogicalSwitchPortVirtualParents", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLogicalSwitchPortVirtualParents indicates an expected call of SetLogicalSwitchPortVirtualParents.
func (mr *MockNbClientMockRecorder) SetLogicalSwitchPortVirtualParents(lsName, parents interface{}, ips ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{lsName, parents}, ips...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogicalSwitchPortVirtualParents", reflect.TypeOf((*MockNbClient)(nil).SetLogicalSwitchPortVirtualParents), varargs...)
}

// SetLogicalSwitchPortVlanTag mocks base method.
func (m *MockNbClient) SetLogicalSwitchPortVlanTag(lspName string, vlanID int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLogicalSwitchPortVlanTag", lspName, vlanID)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLogicalSwitchPortVlanTag indicates an expected call of SetLogicalSwitchPortVlanTag.
func (mr *MockNbClientMockRecorder) SetLogicalSwitchPortVlanTag(lspName, vlanID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogicalSwitchPortVlanTag", reflect.TypeOf((*MockNbClient)(nil).SetLogicalSwitchPortVlanTag), lspName, vlanID)
}

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

// SetLogicalSwitchPortsSecurityGroup indicates an expected call of SetLogicalSwitchPortsSecurityGroup.
func (mr *MockNbClientMockRecorder) SetLogicalSwitchPortsSecurityGroup(sgName, op interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogicalSwitchPortsSecurityGroup", reflect.TypeOf((*MockNbClient)(nil).SetLogicalSwitchPortsSecurityGroup), sgName, op)
}

// SetLogicalSwitchPrivate mocks base method.
func (m *MockNbClient) SetLogicalSwitchPrivate(lsName, cidrBlock, nodeSwitchCIDR string, allowSubnets []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLogicalSwitchPrivate", lsName, cidrBlock, nodeSwitchCIDR, allowSubnets)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLogicalSwitchPrivate indicates an expected call of SetLogicalSwitchPrivate.
func (mr *MockNbClientMockRecorder) SetLogicalSwitchPrivate(lsName, cidrBlock, nodeSwitchCIDR, allowSubnets interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogicalSwitchPrivate", reflect.TypeOf((*MockNbClient)(nil).SetLogicalSwitchPrivate), lsName, cidrBlock, nodeSwitchCIDR, allowSubnets)
}

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

// SetLsCtSkipDstLportIPs indicates an expected call of SetLsCtSkipDstLportIPs.
func (mr *MockNbClientMockRecorder) SetLsCtSkipDstLportIPs(enabled interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLsCtSkipDstLportIPs", reflect.TypeOf((*MockNbClient)(nil).SetLsCtSkipDstLportIPs), enabled)
}

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

// SetLsDnatModDlDst indicates an expected call of SetLsDnatModDlDst.
func (mr *MockNbClientMockRecorder) SetLsDnatModDlDst(enabled interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLsDnatModDlDst", reflect.TypeOf((*MockNbClient)(nil).SetLsDnatModDlDst), enabled)
}

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

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

// Transact mocks base method.
func (m *MockNbClient) Transact(method string, operations []ovsdb.Operation) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Transact", method, operations)
	ret0, _ := ret[0].(error)
	return ret0
}

// Transact indicates an expected call of Transact.
func (mr *MockNbClientMockRecorder) Transact(method, operations interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Transact", reflect.TypeOf((*MockNbClient)(nil).Transact), method, operations)
}

// UpdateDHCPOptions mocks base method.
func (m *MockNbClient) UpdateDHCPOptions(subnet *v1.Subnet, mtu int) (*ovs.DHCPOptionsUUIDs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDHCPOptions", subnet, mtu)
	ret0, _ := ret[0].(*ovs.DHCPOptionsUUIDs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDHCPOptions indicates an expected call of UpdateDHCPOptions.
func (mr *MockNbClientMockRecorder) UpdateDHCPOptions(subnet, mtu interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDHCPOptions", reflect.TypeOf((*MockNbClient)(nil).UpdateDHCPOptions), subnet, mtu)
}

// UpdateDnatAndSnat mocks base method.
func (m *MockNbClient) UpdateDnatAndSnat(lrName, externalIP, logicalIP, lspName, externalMac, gatewayType string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDnatAndSnat", lrName, externalIP, logicalIP, lspName, externalMac, gatewayType)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDnatAndSnat indicates an expected call of UpdateDnatAndSnat.
func (mr *MockNbClientMockRecorder) UpdateDnatAndSnat(lrName, externalIP, logicalIP, lspName, externalMac, gatewayType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDnatAndSnat", reflect.TypeOf((*MockNbClient)(nil).UpdateDnatAndSnat), lrName, externalIP, logicalIP, lspName, externalMac, gatewayType)
}

// UpdateEgressACLOps mocks base method.
func (m *MockNbClient) UpdateEgressACLOps(pgName, asEgressName, asExceptName, protocol string, npp []v10.NetworkPolicyPort, logEnable bool, namedPortMap map[string]*util.NamedPortInfo) ([]ovsdb.Operation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateEgressACLOps", pgName, asEgressName, asExceptName, protocol, npp, logEnable, namedPortMap)
	ret0, _ := ret[0].([]ovsdb.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateEgressACLOps indicates an expected call of UpdateEgressACLOps.
func (mr *MockNbClientMockRecorder) UpdateEgressACLOps(pgName, asEgressName, asExceptName, protocol, npp, logEnable, namedPortMap interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEgressACLOps", reflect.TypeOf((*MockNbClient)(nil).UpdateEgressACLOps), pgName, asEgressName, asExceptName, protocol, npp, logEnable, namedPortMap)
}

// UpdateIngressACLOps mocks base method.
func (m *MockNbClient) UpdateIngressACLOps(pgName, asIngressName, asExceptName, protocol string, npp []v10.NetworkPolicyPort, logEnable bool, namedPortMap map[string]*util.NamedPortInfo) ([]ovsdb.Operation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIngressACLOps", pgName, asIngressName, asExceptName, protocol, npp, logEnable, namedPortMap)
	ret0, _ := ret[0].([]ovsdb.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateIngressACLOps indicates an expected call of UpdateIngressACLOps.
func (mr *MockNbClientMockRecorder) UpdateIngressACLOps(pgName, asIngressName, asExceptName, protocol, npp, logEnable, namedPortMap interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIngressACLOps", reflect.TypeOf((*MockNbClient)(nil).UpdateIngressACLOps), pgName, asIngressName, asExceptName, protocol, npp, logEnable, namedPortMap)
}

// UpdateLogicalRouterPortOptions mocks base method.
func (m *MockNbClient) UpdateLogicalRouterPortOptions(lrpName string, options map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLogicalRouterPortOptions", lrpName, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateLogicalRouterPortOptions indicates an expected call of UpdateLogicalRouterPortOptions.
func (mr *MockNbClientMockRecorder) UpdateLogicalRouterPortOptions(lrpName, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLogicalRouterPortOptions", reflect.TypeOf((*MockNbClient)(nil).UpdateLogicalRouterPortOptions), lrpName, options)
}

// UpdateLogicalRouterPortRA mocks base method.
func (m *MockNbClient) UpdateLogicalRouterPortRA(lrpName, ipv6RAConfigsStr string, enableIPv6RA bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLogicalRouterPortRA", lrpName, ipv6RAConfigsStr, enableIPv6RA)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateLogicalRouterPortRA indicates an expected call of UpdateLogicalRouterPortRA.
func (mr *MockNbClientMockRecorder) UpdateLogicalRouterPortRA(lrpName, ipv6RAConfigsStr, enableIPv6RA interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLogicalRouterPortRA", reflect.TypeOf((*MockNbClient)(nil).UpdateLogicalRouterPortRA), lrpName, ipv6RAConfigsStr, enableIPv6RA)
}

// UpdateLogicalSwitchACL mocks base method.
func (m *MockNbClient) UpdateLogicalSwitchACL(lsName string, subnetAcls []v1.ACL) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLogicalSwitchACL", lsName, subnetAcls)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateLogicalSwitchACL indicates an expected call of UpdateLogicalSwitchACL.
func (mr *MockNbClientMockRecorder) UpdateLogicalSwitchACL(lsName, subnetAcls interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLogicalSwitchACL", reflect.TypeOf((*MockNbClient)(nil).UpdateLogicalSwitchACL), lsName, subnetAcls)
}

// UpdateNbGlobal mocks base method.
func (m *MockNbClient) UpdateNbGlobal(nbGlobal *ovnnb.NBGlobal, fields ...interface{}) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{nbGlobal}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateNbGlobal", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateNbGlobal indicates an expected call of UpdateNbGlobal.
func (mr *MockNbClientMockRecorder) UpdateNbGlobal(nbGlobal interface{}, fields ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{nbGlobal}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNbGlobal", reflect.TypeOf((*MockNbClient)(nil).UpdateNbGlobal), varargs...)
}

// UpdateSgACL mocks base method.
func (m *MockNbClient) UpdateSgACL(sg *v1.SecurityGroup, direction string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSgACL", sg, direction)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateSgACL indicates an expected call of UpdateSgACL.
func (mr *MockNbClientMockRecorder) UpdateSgACL(sg, direction interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSgACL", reflect.TypeOf((*MockNbClient)(nil).UpdateSgACL), sg, direction)
}

// UpdateSnat mocks base method.
func (m *MockNbClient) UpdateSnat(lrName, externalIP, logicalIP string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSnat", lrName, externalIP, logicalIP)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateSnat indicates an expected call of UpdateSnat.
func (mr *MockNbClientMockRecorder) UpdateSnat(lrName, externalIP, logicalIP interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSnat", reflect.TypeOf((*MockNbClient)(nil).UpdateSnat), lrName, externalIP, logicalIP)
}

// MockSbClient is a mock of SbClient interface.
type MockSbClient struct {
	ctrl     *gomock.Controller
	recorder *MockSbClientMockRecorder
}

// MockSbClientMockRecorder is the mock recorder for MockSbClient.
type MockSbClientMockRecorder struct {
	mock *MockSbClient
}

// NewMockSbClient creates a new mock instance.
func NewMockSbClient(ctrl *gomock.Controller) *MockSbClient {
	mock := &MockSbClient{ctrl: ctrl}
	mock.recorder = &MockSbClientMockRecorder{mock}
	return mock
}

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

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

// DeleteChassis indicates an expected call of DeleteChassis.
func (mr *MockSbClientMockRecorder) DeleteChassis(chassisName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChassis", reflect.TypeOf((*MockSbClient)(nil).DeleteChassis), chassisName)
}

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

// DeleteChassisByHost indicates an expected call of DeleteChassisByHost.
func (mr *MockSbClientMockRecorder) DeleteChassisByHost(node interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChassisByHost", reflect.TypeOf((*MockSbClient)(nil).DeleteChassisByHost), node)
}

// GetAllChassisByHost mocks base method.
func (m *MockSbClient) GetAllChassisByHost(nodeName string) (*[]ovnsb.Chassis, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllChassisByHost", nodeName)
	ret0, _ := ret[0].(*[]ovnsb.Chassis)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllChassisByHost indicates an expected call of GetAllChassisByHost.
func (mr *MockSbClientMockRecorder) GetAllChassisByHost(nodeName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllChassisByHost", reflect.TypeOf((*MockSbClient)(nil).GetAllChassisByHost), nodeName)
}

// GetChassis mocks base method.
func (m *MockSbClient) GetChassis(chassisName string, ignoreNotFound bool) (*ovnsb.Chassis, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChassis", chassisName, ignoreNotFound)
	ret0, _ := ret[0].(*ovnsb.Chassis)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChassis indicates an expected call of GetChassis.
func (mr *MockSbClientMockRecorder) GetChassis(chassisName, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChassis", reflect.TypeOf((*MockSbClient)(nil).GetChassis), chassisName, ignoreNotFound)
}

// GetChassisByHost mocks base method.
func (m *MockSbClient) GetChassisByHost(nodeName string) (*ovnsb.Chassis, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChassisByHost", nodeName)
	ret0, _ := ret[0].(*ovnsb.Chassis)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChassisByHost indicates an expected call of GetChassisByHost.
func (mr *MockSbClientMockRecorder) GetChassisByHost(nodeName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChassisByHost", reflect.TypeOf((*MockSbClient)(nil).GetChassisByHost), nodeName)
}

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

// GetEntityInfo indicates an expected call of GetEntityInfo.
func (mr *MockSbClientMockRecorder) GetEntityInfo(entity interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEntityInfo", reflect.TypeOf((*MockSbClient)(nil).GetEntityInfo), entity)
}

// GetKubeOvnChassisses mocks base method.
func (m *MockSbClient) GetKubeOvnChassisses() (*[]ovnsb.Chassis, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKubeOvnChassisses")
	ret0, _ := ret[0].(*[]ovnsb.Chassis)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListChassis mocks base method.
func (m *MockSbClient) ListChassis() (*[]ovnsb.Chassis, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChassis")
	ret0, _ := ret[0].(*[]ovnsb.Chassis)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Transact mocks base method.
func (m *MockSbClient) Transact(method string, operations []ovsdb.Operation) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Transact", method, operations)
	ret0, _ := ret[0].(error)
	return ret0
}

// Transact indicates an expected call of Transact.
func (mr *MockSbClientMockRecorder) Transact(method, operations interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Transact", reflect.TypeOf((*MockSbClient)(nil).Transact), method, operations)
}

// UpdateChassis mocks base method.
func (m *MockSbClient) UpdateChassis(chassis *ovnsb.Chassis, fields ...interface{}) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{chassis}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateChassis", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateChassis indicates an expected call of UpdateChassis.
func (mr *MockSbClientMockRecorder) UpdateChassis(chassis interface{}, fields ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{chassis}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChassis", reflect.TypeOf((*MockSbClient)(nil).UpdateChassis), varargs...)
}

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

// UpdateChassisTag indicates an expected call of UpdateChassisTag.
func (mr *MockSbClientMockRecorder) UpdateChassisTag(chassisName, nodeName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChassisTag", reflect.TypeOf((*MockSbClient)(nil).UpdateChassisTag), chassisName, nodeName)
}

// MockCommon is a mock of Common interface.
type MockCommon struct {
	ctrl     *gomock.Controller
	recorder *MockCommonMockRecorder
}

// MockCommonMockRecorder is the mock recorder for MockCommon.
type MockCommonMockRecorder struct {
	mock *MockCommon
}

// NewMockCommon creates a new mock instance.
func NewMockCommon(ctrl *gomock.Controller) *MockCommon {
	mock := &MockCommon{ctrl: ctrl}
	mock.recorder = &MockCommonMockRecorder{mock}
	return mock
}

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

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

// GetEntityInfo indicates an expected call of GetEntityInfo.
func (mr *MockCommonMockRecorder) GetEntityInfo(entity interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEntityInfo", reflect.TypeOf((*MockCommon)(nil).GetEntityInfo), entity)
}

// Transact mocks base method.
func (m *MockCommon) Transact(method string, operations []ovsdb.Operation) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Transact", method, operations)
	ret0, _ := ret[0].(error)
	return ret0
}

// Transact indicates an expected call of Transact.
func (mr *MockCommonMockRecorder) Transact(method, operations interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Transact", reflect.TypeOf((*MockCommon)(nil).Transact), method, operations)
}

// MockChassis is a mock of Chassis interface.
type MockChassis struct {
	ctrl     *gomock.Controller
	recorder *MockChassisMockRecorder
}

// MockChassisMockRecorder is the mock recorder for MockChassis.
type MockChassisMockRecorder struct {
	mock *MockChassis
}

// NewMockChassis creates a new mock instance.
func NewMockChassis(ctrl *gomock.Controller) *MockChassis {
	mock := &MockChassis{ctrl: ctrl}
	mock.recorder = &MockChassisMockRecorder{mock}
	return mock
}

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

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

// DeleteChassis indicates an expected call of DeleteChassis.
func (mr *MockChassisMockRecorder) DeleteChassis(chassisName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChassis", reflect.TypeOf((*MockChassis)(nil).DeleteChassis), chassisName)
}

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

// DeleteChassisByHost indicates an expected call of DeleteChassisByHost.
func (mr *MockChassisMockRecorder) DeleteChassisByHost(node interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChassisByHost", reflect.TypeOf((*MockChassis)(nil).DeleteChassisByHost), node)
}

// GetAllChassisByHost mocks base method.
func (m *MockChassis) GetAllChassisByHost(nodeName string) (*[]ovnsb.Chassis, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllChassisByHost", nodeName)
	ret0, _ := ret[0].(*[]ovnsb.Chassis)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllChassisByHost indicates an expected call of GetAllChassisByHost.
func (mr *MockChassisMockRecorder) GetAllChassisByHost(nodeName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllChassisByHost", reflect.TypeOf((*MockChassis)(nil).GetAllChassisByHost), nodeName)
}

// GetChassis mocks base method.
func (m *MockChassis) GetChassis(chassisName string, ignoreNotFound bool) (*ovnsb.Chassis, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChassis", chassisName, ignoreNotFound)
	ret0, _ := ret[0].(*ovnsb.Chassis)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChassis indicates an expected call of GetChassis.
func (mr *MockChassisMockRecorder) GetChassis(chassisName, ignoreNotFound interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChassis", reflect.TypeOf((*MockChassis)(nil).GetChassis), chassisName, ignoreNotFound)
}

// GetChassisByHost mocks base method.
func (m *MockChassis) GetChassisByHost(nodeName string) (*ovnsb.Chassis, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChassisByHost", nodeName)
	ret0, _ := ret[0].(*ovnsb.Chassis)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChassisByHost indicates an expected call of GetChassisByHost.
func (mr *MockChassisMockRecorder) GetChassisByHost(nodeName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChassisByHost", reflect.TypeOf((*MockChassis)(nil).GetChassisByHost), nodeName)
}

// GetKubeOvnChassisses mocks base method.
func (m *MockChassis) GetKubeOvnChassisses() (*[]ovnsb.Chassis, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKubeOvnChassisses")
	ret0, _ := ret[0].(*[]ovnsb.Chassis)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListChassis mocks base method.
func (m *MockChassis) ListChassis() (*[]ovnsb.Chassis, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChassis")
	ret0, _ := ret[0].(*[]ovnsb.Chassis)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateChassis mocks base method.
func (m *MockChassis) UpdateChassis(chassis *ovnsb.Chassis, fields ...interface{}) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{chassis}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateChassis", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateChassis indicates an expected call of UpdateChassis.
func (mr *MockChassisMockRecorder) UpdateChassis(chassis interface{}, fields ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{chassis}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChassis", reflect.TypeOf((*MockChassis)(nil).UpdateChassis), varargs...)
}

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

// UpdateChassisTag indicates an expected call of UpdateChassisTag.
func (mr *MockChassisMockRecorder) UpdateChassisTag(chassisName, nodeName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChassisTag", reflect.TypeOf((*MockChassis)(nil).UpdateChassisTag), chassisName, nodeName)
}