// Code generated by mockery v1.0.0. DO NOT EDIT.

package mocks

import (
	goovn "github.com/ebay/go-ovn"
	mock "github.com/stretchr/testify/mock"
)

// Client is an autogenerated mock type for the Client type
type Client struct {
	mock.Mock
}

// ACLAdd provides a mock function with given fields: ls, direct, match, action, priority, external_ids, logflag, meter, severity
func (_m *Client) ACLAdd(ls string, direct string, match string, action string, priority int, external_ids map[string]string, logflag bool, meter string, severity string) (*goovn.OvnCommand, error) {
	ret := _m.Called(ls, direct, match, action, priority, external_ids, logflag, meter, severity)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string, string, string, int, map[string]string, bool, string, string) *goovn.OvnCommand); ok {
		r0 = rf(ls, direct, match, action, priority, external_ids, logflag, meter, severity)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string, string, string, int, map[string]string, bool, string, string) error); ok {
		r1 = rf(ls, direct, match, action, priority, external_ids, logflag, meter, severity)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ACLDel provides a mock function with given fields: ls, direct, match, priority, external_ids
func (_m *Client) ACLDel(ls string, direct string, match string, priority int, external_ids map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(ls, direct, match, priority, external_ids)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string, string, int, map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(ls, direct, match, priority, external_ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string, string, int, map[string]string) error); ok {
		r1 = rf(ls, direct, match, priority, external_ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ACLList provides a mock function with given fields: ls
func (_m *Client) ACLList(ls string) ([]*goovn.ACL, error) {
	ret := _m.Called(ls)

	var r0 []*goovn.ACL
	if rf, ok := ret.Get(0).(func(string) []*goovn.ACL); ok {
		r0 = rf(ls)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.ACL)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(ls)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ASAdd provides a mock function with given fields: name, addrs, external_ids
func (_m *Client) ASAdd(name string, addrs []string, external_ids map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(name, addrs, external_ids)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, []string, map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(name, addrs, external_ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, []string, map[string]string) error); ok {
		r1 = rf(name, addrs, external_ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ASDel provides a mock function with given fields: name
func (_m *Client) ASDel(name string) (*goovn.OvnCommand, error) {
	ret := _m.Called(name)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string) *goovn.OvnCommand); ok {
		r0 = rf(name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ASGet provides a mock function with given fields: name
func (_m *Client) ASGet(name string) (*goovn.AddressSet, error) {
	ret := _m.Called(name)

	var r0 *goovn.AddressSet
	if rf, ok := ret.Get(0).(func(string) *goovn.AddressSet); ok {
		r0 = rf(name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.AddressSet)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ASList provides a mock function with given fields:
func (_m *Client) ASList() ([]*goovn.AddressSet, error) {
	ret := _m.Called()

	var r0 []*goovn.AddressSet
	if rf, ok := ret.Get(0).(func() []*goovn.AddressSet); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.AddressSet)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ASUpdate provides a mock function with given fields: name, addrs, external_ids
func (_m *Client) ASUpdate(name string, addrs []string, external_ids map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(name, addrs, external_ids)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, []string, map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(name, addrs, external_ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, []string, map[string]string) error); ok {
		r1 = rf(name, addrs, external_ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ChassisAdd provides a mock function with given fields: name, hostname, etype, ip, external_ids, transport_zones, vtep_lswitches
func (_m *Client) ChassisAdd(name string, hostname string, etype []string, ip string, external_ids map[string]string, transport_zones []string, vtep_lswitches []string) (*goovn.OvnCommand, error) {
	ret := _m.Called(name, hostname, etype, ip, external_ids, transport_zones, vtep_lswitches)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string, []string, string, map[string]string, []string, []string) *goovn.OvnCommand); ok {
		r0 = rf(name, hostname, etype, ip, external_ids, transport_zones, vtep_lswitches)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string, []string, string, map[string]string, []string, []string) error); ok {
		r1 = rf(name, hostname, etype, ip, external_ids, transport_zones, vtep_lswitches)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ChassisDel provides a mock function with given fields: chName
func (_m *Client) ChassisDel(chName string) (*goovn.OvnCommand, error) {
	ret := _m.Called(chName)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string) *goovn.OvnCommand); ok {
		r0 = rf(chName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(chName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ChassisGet provides a mock function with given fields: chname
func (_m *Client) ChassisGet(chname string) ([]*goovn.Chassis, error) {
	ret := _m.Called(chname)

	var r0 []*goovn.Chassis
	if rf, ok := ret.Get(0).(func(string) []*goovn.Chassis); ok {
		r0 = rf(chname)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.Chassis)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(chname)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ChassisList provides a mock function with given fields:
func (_m *Client) ChassisList() ([]*goovn.Chassis, error) {
	ret := _m.Called()

	var r0 []*goovn.Chassis
	if rf, ok := ret.Get(0).(func() []*goovn.Chassis); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.Chassis)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Close provides a mock function with given fields:
func (_m *Client) Close() error {
	ret := _m.Called()

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DHCPOptionsAdd provides a mock function with given fields: cidr, options, external_ids
func (_m *Client) DHCPOptionsAdd(cidr string, options map[string]string, external_ids map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(cidr, options, external_ids)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, map[string]string, map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(cidr, options, external_ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, map[string]string, map[string]string) error); ok {
		r1 = rf(cidr, options, external_ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DHCPOptionsDel provides a mock function with given fields: uuid
func (_m *Client) DHCPOptionsDel(uuid string) (*goovn.OvnCommand, error) {
	ret := _m.Called(uuid)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string) *goovn.OvnCommand); ok {
		r0 = rf(uuid)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(uuid)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DHCPOptionsGet provides a mock function with given fields: uuid
func (_m *Client) DHCPOptionsGet(uuid string) (*goovn.DHCPOptions, error) {
	ret := _m.Called(uuid)

	var r0 *goovn.DHCPOptions
	if rf, ok := ret.Get(0).(func(string) *goovn.DHCPOptions); ok {
		r0 = rf(uuid)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.DHCPOptions)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(uuid)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DHCPOptionsList provides a mock function with given fields:
func (_m *Client) DHCPOptionsList() ([]*goovn.DHCPOptions, error) {
	ret := _m.Called()

	var r0 []*goovn.DHCPOptions
	if rf, ok := ret.Get(0).(func() []*goovn.DHCPOptions); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.DHCPOptions)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DHCPOptionsSet provides a mock function with given fields: uuid, options, external_ids
func (_m *Client) DHCPOptionsSet(uuid string, options map[string]string, external_ids map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(uuid, options, external_ids)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, map[string]string, map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(uuid, options, external_ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, map[string]string, map[string]string) error); ok {
		r1 = rf(uuid, options, external_ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EncapList provides a mock function with given fields: chname
func (_m *Client) EncapList(chname string) ([]*goovn.Encap, error) {
	ret := _m.Called(chname)

	var r0 []*goovn.Encap
	if rf, ok := ret.Get(0).(func(string) []*goovn.Encap); ok {
		r0 = rf(chname)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.Encap)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(chname)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Execute provides a mock function with given fields: cmds
func (_m *Client) Execute(cmds ...*goovn.OvnCommand) error {
	_va := make([]interface{}, len(cmds))
	for _i := range cmds {
		_va[_i] = cmds[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(...*goovn.OvnCommand) error); ok {
		r0 = rf(cmds...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// LBAdd provides a mock function with given fields: name, vipPort, protocol, addrs
func (_m *Client) LBAdd(name string, vipPort string, protocol string, addrs []string) (*goovn.OvnCommand, error) {
	ret := _m.Called(name, vipPort, protocol, addrs)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string, string, []string) *goovn.OvnCommand); ok {
		r0 = rf(name, vipPort, protocol, addrs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string, string, []string) error); ok {
		r1 = rf(name, vipPort, protocol, addrs)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LBDel provides a mock function with given fields: name
func (_m *Client) LBDel(name string) (*goovn.OvnCommand, error) {
	ret := _m.Called(name)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string) *goovn.OvnCommand); ok {
		r0 = rf(name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LBGet provides a mock function with given fields: name
func (_m *Client) LBGet(name string) ([]*goovn.LoadBalancer, error) {
	ret := _m.Called(name)

	var r0 []*goovn.LoadBalancer
	if rf, ok := ret.Get(0).(func(string) []*goovn.LoadBalancer); ok {
		r0 = rf(name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.LoadBalancer)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LBUpdate provides a mock function with given fields: name, vipPort, protocol, addrs
func (_m *Client) LBUpdate(name string, vipPort string, protocol string, addrs []string) (*goovn.OvnCommand, error) {
	ret := _m.Called(name, vipPort, protocol, addrs)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string, string, []string) *goovn.OvnCommand); ok {
		r0 = rf(name, vipPort, protocol, addrs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string, string, []string) error); ok {
		r1 = rf(name, vipPort, protocol, addrs)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRAdd provides a mock function with given fields: name, external_ids
func (_m *Client) LRAdd(name string, external_ids map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(name, external_ids)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(name, external_ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, map[string]string) error); ok {
		r1 = rf(name, external_ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRDel provides a mock function with given fields: name
func (_m *Client) LRDel(name string) (*goovn.OvnCommand, error) {
	ret := _m.Called(name)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string) *goovn.OvnCommand); ok {
		r0 = rf(name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRGet provides a mock function with given fields: name
func (_m *Client) LRGet(name string) ([]*goovn.LogicalRouter, error) {
	ret := _m.Called(name)

	var r0 []*goovn.LogicalRouter
	if rf, ok := ret.Get(0).(func(string) []*goovn.LogicalRouter); ok {
		r0 = rf(name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.LogicalRouter)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRLBAdd provides a mock function with given fields: lr, lb
func (_m *Client) LRLBAdd(lr string, lb string) (*goovn.OvnCommand, error) {
	ret := _m.Called(lr, lb)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string) *goovn.OvnCommand); ok {
		r0 = rf(lr, lb)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string) error); ok {
		r1 = rf(lr, lb)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRLBDel provides a mock function with given fields: lr, lb
func (_m *Client) LRLBDel(lr string, lb string) (*goovn.OvnCommand, error) {
	ret := _m.Called(lr, lb)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string) *goovn.OvnCommand); ok {
		r0 = rf(lr, lb)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string) error); ok {
		r1 = rf(lr, lb)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRLBList provides a mock function with given fields: lr
func (_m *Client) LRLBList(lr string) ([]*goovn.LoadBalancer, error) {
	ret := _m.Called(lr)

	var r0 []*goovn.LoadBalancer
	if rf, ok := ret.Get(0).(func(string) []*goovn.LoadBalancer); ok {
		r0 = rf(lr)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.LoadBalancer)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(lr)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRList provides a mock function with given fields:
func (_m *Client) LRList() ([]*goovn.LogicalRouter, error) {
	ret := _m.Called()

	var r0 []*goovn.LogicalRouter
	if rf, ok := ret.Get(0).(func() []*goovn.LogicalRouter); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.LogicalRouter)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRNATAdd provides a mock function with given fields: lr, ntype, externalIp, logicalIp, external_ids, logicalPortAndExternalMac
func (_m *Client) LRNATAdd(lr string, ntype string, externalIp string, logicalIp string, external_ids map[string]string, logicalPortAndExternalMac ...string) (*goovn.OvnCommand, error) {
	_va := make([]interface{}, len(logicalPortAndExternalMac))
	for _i := range logicalPortAndExternalMac {
		_va[_i] = logicalPortAndExternalMac[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, lr, ntype, externalIp, logicalIp, external_ids)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string, string, string, map[string]string, ...string) *goovn.OvnCommand); ok {
		r0 = rf(lr, ntype, externalIp, logicalIp, external_ids, logicalPortAndExternalMac...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string, string, string, map[string]string, ...string) error); ok {
		r1 = rf(lr, ntype, externalIp, logicalIp, external_ids, logicalPortAndExternalMac...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRNATDel provides a mock function with given fields: lr, ntype, ip
func (_m *Client) LRNATDel(lr string, ntype string, ip ...string) (*goovn.OvnCommand, error) {
	_va := make([]interface{}, len(ip))
	for _i := range ip {
		_va[_i] = ip[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, lr, ntype)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string, ...string) *goovn.OvnCommand); ok {
		r0 = rf(lr, ntype, ip...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string, ...string) error); ok {
		r1 = rf(lr, ntype, ip...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRNATList provides a mock function with given fields: lr
func (_m *Client) LRNATList(lr string) ([]*goovn.NAT, error) {
	ret := _m.Called(lr)

	var r0 []*goovn.NAT
	if rf, ok := ret.Get(0).(func(string) []*goovn.NAT); ok {
		r0 = rf(lr)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.NAT)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(lr)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRPAdd provides a mock function with given fields: lr, lrp, mac, network, peer, external_ids
func (_m *Client) LRPAdd(lr string, lrp string, mac string, network []string, peer string, external_ids map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(lr, lrp, mac, network, peer, external_ids)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string, string, []string, string, map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(lr, lrp, mac, network, peer, external_ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string, string, []string, string, map[string]string) error); ok {
		r1 = rf(lr, lrp, mac, network, peer, external_ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRPDel provides a mock function with given fields: lr, lrp
func (_m *Client) LRPDel(lr string, lrp string) (*goovn.OvnCommand, error) {
	ret := _m.Called(lr, lrp)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string) *goovn.OvnCommand); ok {
		r0 = rf(lr, lrp)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string) error); ok {
		r1 = rf(lr, lrp)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRPList provides a mock function with given fields: lr
func (_m *Client) LRPList(lr string) ([]*goovn.LogicalRouterPort, error) {
	ret := _m.Called(lr)

	var r0 []*goovn.LogicalRouterPort
	if rf, ok := ret.Get(0).(func(string) []*goovn.LogicalRouterPort); ok {
		r0 = rf(lr)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.LogicalRouterPort)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(lr)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRSRAdd provides a mock function with given fields: lr, ip_prefix, nexthop, output_port, policy, external_ids
func (_m *Client) LRSRAdd(lr string, ip_prefix string, nexthop string, output_port []string, policy []string, external_ids map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(lr, ip_prefix, nexthop, output_port, policy, external_ids)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string, string, []string, []string, map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(lr, ip_prefix, nexthop, output_port, policy, external_ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string, string, []string, []string, map[string]string) error); ok {
		r1 = rf(lr, ip_prefix, nexthop, output_port, policy, external_ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRSRDel provides a mock function with given fields: lr, prefix, nexthop, policy, outputPort
func (_m *Client) LRSRDel(lr string, prefix string, nexthop *string, policy *string, outputPort *string) (*goovn.OvnCommand, error) {
	ret := _m.Called(lr, prefix, nexthop, policy, outputPort)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string, *string, *string, *string) *goovn.OvnCommand); ok {
		r0 = rf(lr, prefix, nexthop, policy, outputPort)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string, *string, *string, *string) error); ok {
		r1 = rf(lr, prefix, nexthop, policy, outputPort)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRSRDelByUUID provides a mock function with given fields: lr, uuid
func (_m *Client) LRSRDelByUUID(lr string, uuid string) (*goovn.OvnCommand, error) {
	ret := _m.Called(lr, uuid)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string) *goovn.OvnCommand); ok {
		r0 = rf(lr, uuid)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string) error); ok {
		r1 = rf(lr, uuid)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LRSRList provides a mock function with given fields: lr
func (_m *Client) LRSRList(lr string) ([]*goovn.LogicalRouterStaticRoute, error) {
	ret := _m.Called(lr)

	var r0 []*goovn.LogicalRouterStaticRoute
	if rf, ok := ret.Get(0).(func(string) []*goovn.LogicalRouterStaticRoute); ok {
		r0 = rf(lr)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.LogicalRouterStaticRoute)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(lr)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSAdd provides a mock function with given fields: ls
func (_m *Client) LSAdd(ls string) (*goovn.OvnCommand, error) {
	ret := _m.Called(ls)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string) *goovn.OvnCommand); ok {
		r0 = rf(ls)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(ls)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSDel provides a mock function with given fields: ls
func (_m *Client) LSDel(ls string) (*goovn.OvnCommand, error) {
	ret := _m.Called(ls)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string) *goovn.OvnCommand); ok {
		r0 = rf(ls)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(ls)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSExtIdsAdd provides a mock function with given fields: ls, external_ids
func (_m *Client) LSExtIdsAdd(ls string, external_ids map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(ls, external_ids)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(ls, external_ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, map[string]string) error); ok {
		r1 = rf(ls, external_ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSExtIdsDel provides a mock function with given fields: ls, external_ids
func (_m *Client) LSExtIdsDel(ls string, external_ids map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(ls, external_ids)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(ls, external_ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, map[string]string) error); ok {
		r1 = rf(ls, external_ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSGet provides a mock function with given fields: ls
func (_m *Client) LSGet(ls string) ([]*goovn.LogicalSwitch, error) {
	ret := _m.Called(ls)

	var r0 []*goovn.LogicalSwitch
	if rf, ok := ret.Get(0).(func(string) []*goovn.LogicalSwitch); ok {
		r0 = rf(ls)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.LogicalSwitch)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(ls)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSLBAdd provides a mock function with given fields: ls, lb
func (_m *Client) LSLBAdd(ls string, lb string) (*goovn.OvnCommand, error) {
	ret := _m.Called(ls, lb)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string) *goovn.OvnCommand); ok {
		r0 = rf(ls, lb)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string) error); ok {
		r1 = rf(ls, lb)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSLBDel provides a mock function with given fields: ls, lb
func (_m *Client) LSLBDel(ls string, lb string) (*goovn.OvnCommand, error) {
	ret := _m.Called(ls, lb)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string) *goovn.OvnCommand); ok {
		r0 = rf(ls, lb)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string) error); ok {
		r1 = rf(ls, lb)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSLBList provides a mock function with given fields: ls
func (_m *Client) LSLBList(ls string) ([]*goovn.LoadBalancer, error) {
	ret := _m.Called(ls)

	var r0 []*goovn.LoadBalancer
	if rf, ok := ret.Get(0).(func(string) []*goovn.LoadBalancer); ok {
		r0 = rf(ls)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.LoadBalancer)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(ls)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSList provides a mock function with given fields:
func (_m *Client) LSList() ([]*goovn.LogicalSwitch, error) {
	ret := _m.Called()

	var r0 []*goovn.LogicalSwitch
	if rf, ok := ret.Get(0).(func() []*goovn.LogicalSwitch); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.LogicalSwitch)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPAdd provides a mock function with given fields: ls, lsp
func (_m *Client) LSPAdd(ls string, lsp string) (*goovn.OvnCommand, error) {
	ret := _m.Called(ls, lsp)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string) *goovn.OvnCommand); ok {
		r0 = rf(ls, lsp)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string) error); ok {
		r1 = rf(ls, lsp)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPDel provides a mock function with given fields: lsp
func (_m *Client) LSPDel(lsp string) (*goovn.OvnCommand, error) {
	ret := _m.Called(lsp)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string) *goovn.OvnCommand); ok {
		r0 = rf(lsp)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(lsp)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPGet provides a mock function with given fields: lsp
func (_m *Client) LSPGet(lsp string) (*goovn.LogicalSwitchPort, error) {
	ret := _m.Called(lsp)

	var r0 *goovn.LogicalSwitchPort
	if rf, ok := ret.Get(0).(func(string) *goovn.LogicalSwitchPort); ok {
		r0 = rf(lsp)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.LogicalSwitchPort)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(lsp)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPGetDHCPv4Options provides a mock function with given fields: lsp
func (_m *Client) LSPGetDHCPv4Options(lsp string) (*goovn.DHCPOptions, error) {
	ret := _m.Called(lsp)

	var r0 *goovn.DHCPOptions
	if rf, ok := ret.Get(0).(func(string) *goovn.DHCPOptions); ok {
		r0 = rf(lsp)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.DHCPOptions)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(lsp)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPGetDHCPv6Options provides a mock function with given fields: lsp
func (_m *Client) LSPGetDHCPv6Options(lsp string) (*goovn.DHCPOptions, error) {
	ret := _m.Called(lsp)

	var r0 *goovn.DHCPOptions
	if rf, ok := ret.Get(0).(func(string) *goovn.DHCPOptions); ok {
		r0 = rf(lsp)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.DHCPOptions)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(lsp)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPGetDynamicAddresses provides a mock function with given fields: lsp
func (_m *Client) LSPGetDynamicAddresses(lsp string) (string, error) {
	ret := _m.Called(lsp)

	var r0 string
	if rf, ok := ret.Get(0).(func(string) string); ok {
		r0 = rf(lsp)
	} else {
		r0 = ret.Get(0).(string)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(lsp)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPGetExternalIds provides a mock function with given fields: lsp
func (_m *Client) LSPGetExternalIds(lsp string) (map[string]string, error) {
	ret := _m.Called(lsp)

	var r0 map[string]string
	if rf, ok := ret.Get(0).(func(string) map[string]string); ok {
		r0 = rf(lsp)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(lsp)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPGetOptions provides a mock function with given fields: lsp
func (_m *Client) LSPGetOptions(lsp string) (map[string]string, error) {
	ret := _m.Called(lsp)

	var r0 map[string]string
	if rf, ok := ret.Get(0).(func(string) map[string]string); ok {
		r0 = rf(lsp)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(lsp)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPList provides a mock function with given fields: ls
func (_m *Client) LSPList(ls string) ([]*goovn.LogicalSwitchPort, error) {
	ret := _m.Called(ls)

	var r0 []*goovn.LogicalSwitchPort
	if rf, ok := ret.Get(0).(func(string) []*goovn.LogicalSwitchPort); ok {
		r0 = rf(ls)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.LogicalSwitchPort)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(ls)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPSetAddress provides a mock function with given fields: lsp, addresses
func (_m *Client) LSPSetAddress(lsp string, addresses ...string) (*goovn.OvnCommand, error) {
	_va := make([]interface{}, len(addresses))
	for _i := range addresses {
		_va[_i] = addresses[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, lsp)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, ...string) *goovn.OvnCommand); ok {
		r0 = rf(lsp, addresses...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, ...string) error); ok {
		r1 = rf(lsp, addresses...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPSetDHCPv4Options provides a mock function with given fields: lsp, options
func (_m *Client) LSPSetDHCPv4Options(lsp string, options string) (*goovn.OvnCommand, error) {
	ret := _m.Called(lsp, options)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string) *goovn.OvnCommand); ok {
		r0 = rf(lsp, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string) error); ok {
		r1 = rf(lsp, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPSetDHCPv6Options provides a mock function with given fields: lsp, options
func (_m *Client) LSPSetDHCPv6Options(lsp string, options string) (*goovn.OvnCommand, error) {
	ret := _m.Called(lsp, options)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string) *goovn.OvnCommand); ok {
		r0 = rf(lsp, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string) error); ok {
		r1 = rf(lsp, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPSetDynamicAddresses provides a mock function with given fields: lsp, address
func (_m *Client) LSPSetDynamicAddresses(lsp string, address string) (*goovn.OvnCommand, error) {
	ret := _m.Called(lsp, address)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string) *goovn.OvnCommand); ok {
		r0 = rf(lsp, address)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string) error); ok {
		r1 = rf(lsp, address)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPSetExternalIds provides a mock function with given fields: lsp, external_ids
func (_m *Client) LSPSetExternalIds(lsp string, external_ids map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(lsp, external_ids)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(lsp, external_ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, map[string]string) error); ok {
		r1 = rf(lsp, external_ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPSetOptions provides a mock function with given fields: lsp, options
func (_m *Client) LSPSetOptions(lsp string, options map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(lsp, options)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(lsp, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, map[string]string) error); ok {
		r1 = rf(lsp, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LSPSetPortSecurity provides a mock function with given fields: lsp, security
func (_m *Client) LSPSetPortSecurity(lsp string, security ...string) (*goovn.OvnCommand, error) {
	_va := make([]interface{}, len(security))
	for _i := range security {
		_va[_i] = security[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, lsp)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, ...string) *goovn.OvnCommand); ok {
		r0 = rf(lsp, security...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, ...string) error); ok {
		r1 = rf(lsp, security...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LinkSwitchToRouter provides a mock function with given fields: lsw, lsp, lr, lrp, lrpMac, networks, externalIds
func (_m *Client) LinkSwitchToRouter(lsw string, lsp string, lr string, lrp string, lrpMac string, networks []string, externalIds map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(lsw, lsp, lr, lrp, lrpMac, networks, externalIds)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string, string, string, string, []string, map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(lsw, lsp, lr, lrp, lrpMac, networks, externalIds)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string, string, string, string, []string, map[string]string) error); ok {
		r1 = rf(lsw, lsp, lr, lrp, lrpMac, networks, externalIds)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MeterAdd provides a mock function with given fields: name, action, rate, unit, external_ids, burst
func (_m *Client) MeterAdd(name string, action string, rate int, unit string, external_ids map[string]string, burst int) (*goovn.OvnCommand, error) {
	ret := _m.Called(name, action, rate, unit, external_ids, burst)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string, int, string, map[string]string, int) *goovn.OvnCommand); ok {
		r0 = rf(name, action, rate, unit, external_ids, burst)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string, int, string, map[string]string, int) error); ok {
		r1 = rf(name, action, rate, unit, external_ids, burst)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MeterBandsList provides a mock function with given fields:
func (_m *Client) MeterBandsList() ([]*goovn.MeterBand, error) {
	ret := _m.Called()

	var r0 []*goovn.MeterBand
	if rf, ok := ret.Get(0).(func() []*goovn.MeterBand); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.MeterBand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MeterDel provides a mock function with given fields: name
func (_m *Client) MeterDel(name ...string) (*goovn.OvnCommand, error) {
	_va := make([]interface{}, len(name))
	for _i := range name {
		_va[_i] = name[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(...string) *goovn.OvnCommand); ok {
		r0 = rf(name...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(...string) error); ok {
		r1 = rf(name...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MeterList provides a mock function with given fields:
func (_m *Client) MeterList() ([]*goovn.Meter, error) {
	ret := _m.Called()

	var r0 []*goovn.Meter
	if rf, ok := ret.Get(0).(func() []*goovn.Meter); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.Meter)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// NBGlobalGetOptions provides a mock function with given fields:
func (_m *Client) NBGlobalGetOptions() (map[string]string, error) {
	ret := _m.Called()

	var r0 map[string]string
	if rf, ok := ret.Get(0).(func() map[string]string); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// NBGlobalSetOptions provides a mock function with given fields: options
func (_m *Client) NBGlobalSetOptions(options map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(options)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(map[string]string) error); ok {
		r1 = rf(options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// QoSAdd provides a mock function with given fields: ls, direction, priority, match, action, bandwidth, external_ids
func (_m *Client) QoSAdd(ls string, direction string, priority int, match string, action map[string]int, bandwidth map[string]int, external_ids map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(ls, direction, priority, match, action, bandwidth, external_ids)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string, int, string, map[string]int, map[string]int, map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(ls, direction, priority, match, action, bandwidth, external_ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string, int, string, map[string]int, map[string]int, map[string]string) error); ok {
		r1 = rf(ls, direction, priority, match, action, bandwidth, external_ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// QoSDel provides a mock function with given fields: ls, direction, priority, match
func (_m *Client) QoSDel(ls string, direction string, priority int, match string) (*goovn.OvnCommand, error) {
	ret := _m.Called(ls, direction, priority, match)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(string, string, int, string) *goovn.OvnCommand); ok {
		r0 = rf(ls, direction, priority, match)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string, string, int, string) error); ok {
		r1 = rf(ls, direction, priority, match)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// QoSList provides a mock function with given fields: ls
func (_m *Client) QoSList(ls string) ([]*goovn.QoS, error) {
	ret := _m.Called(ls)

	var r0 []*goovn.QoS
	if rf, ok := ret.Get(0).(func(string) []*goovn.QoS); ok {
		r0 = rf(ls)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*goovn.QoS)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(ls)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SBGlobalGetOptions provides a mock function with given fields:
func (_m *Client) SBGlobalGetOptions() (map[string]string, error) {
	ret := _m.Called()

	var r0 map[string]string
	if rf, ok := ret.Get(0).(func() map[string]string); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SBGlobalSetOptions provides a mock function with given fields: options
func (_m *Client) SBGlobalSetOptions(options map[string]string) (*goovn.OvnCommand, error) {
	ret := _m.Called(options)

	var r0 *goovn.OvnCommand
	if rf, ok := ret.Get(0).(func(map[string]string) *goovn.OvnCommand); ok {
		r0 = rf(options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*goovn.OvnCommand)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(map[string]string) error); ok {
		r1 = rf(options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}
