// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package gonetworkmanager

import (
	"github.com/Wifx/gonetworkmanager/v2"
	"github.com/godbus/dbus/v5"
	mock "github.com/stretchr/testify/mock"
)

// NewMockNetworkManager creates a new instance of MockNetworkManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockNetworkManager(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockNetworkManager {
	mock := &MockNetworkManager{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

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

type MockNetworkManager_Expecter struct {
	mock *mock.Mock
}

func (_m *MockNetworkManager) EXPECT() *MockNetworkManager_Expecter {
	return &MockNetworkManager_Expecter{mock: &_m.Mock}
}

// ActivateConnection provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) ActivateConnection(connection gonetworkmanager.Connection, device gonetworkmanager.Device, specificObject *dbus.Object) (gonetworkmanager.ActiveConnection, error) {
	ret := _mock.Called(connection, device, specificObject)

	if len(ret) == 0 {
		panic("no return value specified for ActivateConnection")
	}

	var r0 gonetworkmanager.ActiveConnection
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(gonetworkmanager.Connection, gonetworkmanager.Device, *dbus.Object) (gonetworkmanager.ActiveConnection, error)); ok {
		return returnFunc(connection, device, specificObject)
	}
	if returnFunc, ok := ret.Get(0).(func(gonetworkmanager.Connection, gonetworkmanager.Device, *dbus.Object) gonetworkmanager.ActiveConnection); ok {
		r0 = returnFunc(connection, device, specificObject)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(gonetworkmanager.ActiveConnection)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(gonetworkmanager.Connection, gonetworkmanager.Device, *dbus.Object) error); ok {
		r1 = returnFunc(connection, device, specificObject)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_ActivateConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ActivateConnection'
type MockNetworkManager_ActivateConnection_Call struct {
	*mock.Call
}

// ActivateConnection is a helper method to define mock.On call
//   - connection gonetworkmanager.Connection
//   - device gonetworkmanager.Device
//   - specificObject *dbus.Object
func (_e *MockNetworkManager_Expecter) ActivateConnection(connection any, device any, specificObject any) *MockNetworkManager_ActivateConnection_Call {
	return &MockNetworkManager_ActivateConnection_Call{Call: _e.mock.On("ActivateConnection", connection, device, specificObject)}
}

func (_c *MockNetworkManager_ActivateConnection_Call) Run(run func(connection gonetworkmanager.Connection, device gonetworkmanager.Device, specificObject *dbus.Object)) *MockNetworkManager_ActivateConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gonetworkmanager.Connection
		if args[0] != nil {
			arg0 = args[0].(gonetworkmanager.Connection)
		}
		var arg1 gonetworkmanager.Device
		if args[1] != nil {
			arg1 = args[1].(gonetworkmanager.Device)
		}
		var arg2 *dbus.Object
		if args[2] != nil {
			arg2 = args[2].(*dbus.Object)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockNetworkManager_ActivateConnection_Call) Return(activeConnection gonetworkmanager.ActiveConnection, err error) *MockNetworkManager_ActivateConnection_Call {
	_c.Call.Return(activeConnection, err)
	return _c
}

func (_c *MockNetworkManager_ActivateConnection_Call) RunAndReturn(run func(connection gonetworkmanager.Connection, device gonetworkmanager.Device, specificObject *dbus.Object) (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_ActivateConnection_Call {
	_c.Call.Return(run)
	return _c
}

// ActivateWirelessConnection provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) ActivateWirelessConnection(connection gonetworkmanager.Connection, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error) {
	ret := _mock.Called(connection, device, accessPoint)

	if len(ret) == 0 {
		panic("no return value specified for ActivateWirelessConnection")
	}

	var r0 gonetworkmanager.ActiveConnection
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(gonetworkmanager.Connection, gonetworkmanager.Device, gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error)); ok {
		return returnFunc(connection, device, accessPoint)
	}
	if returnFunc, ok := ret.Get(0).(func(gonetworkmanager.Connection, gonetworkmanager.Device, gonetworkmanager.AccessPoint) gonetworkmanager.ActiveConnection); ok {
		r0 = returnFunc(connection, device, accessPoint)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(gonetworkmanager.ActiveConnection)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(gonetworkmanager.Connection, gonetworkmanager.Device, gonetworkmanager.AccessPoint) error); ok {
		r1 = returnFunc(connection, device, accessPoint)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_ActivateWirelessConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ActivateWirelessConnection'
type MockNetworkManager_ActivateWirelessConnection_Call struct {
	*mock.Call
}

// ActivateWirelessConnection is a helper method to define mock.On call
//   - connection gonetworkmanager.Connection
//   - device gonetworkmanager.Device
//   - accessPoint gonetworkmanager.AccessPoint
func (_e *MockNetworkManager_Expecter) ActivateWirelessConnection(connection any, device any, accessPoint any) *MockNetworkManager_ActivateWirelessConnection_Call {
	return &MockNetworkManager_ActivateWirelessConnection_Call{Call: _e.mock.On("ActivateWirelessConnection", connection, device, accessPoint)}
}

func (_c *MockNetworkManager_ActivateWirelessConnection_Call) Run(run func(connection gonetworkmanager.Connection, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint)) *MockNetworkManager_ActivateWirelessConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gonetworkmanager.Connection
		if args[0] != nil {
			arg0 = args[0].(gonetworkmanager.Connection)
		}
		var arg1 gonetworkmanager.Device
		if args[1] != nil {
			arg1 = args[1].(gonetworkmanager.Device)
		}
		var arg2 gonetworkmanager.AccessPoint
		if args[2] != nil {
			arg2 = args[2].(gonetworkmanager.AccessPoint)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockNetworkManager_ActivateWirelessConnection_Call) Return(activeConnection gonetworkmanager.ActiveConnection, err error) *MockNetworkManager_ActivateWirelessConnection_Call {
	_c.Call.Return(activeConnection, err)
	return _c
}

func (_c *MockNetworkManager_ActivateWirelessConnection_Call) RunAndReturn(run func(connection gonetworkmanager.Connection, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_ActivateWirelessConnection_Call {
	_c.Call.Return(run)
	return _c
}

// AddAndActivateConnection provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) AddAndActivateConnection(connection map[string]map[string]interface{}, device gonetworkmanager.Device) (gonetworkmanager.ActiveConnection, error) {
	ret := _mock.Called(connection, device)

	if len(ret) == 0 {
		panic("no return value specified for AddAndActivateConnection")
	}

	var r0 gonetworkmanager.ActiveConnection
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(map[string]map[string]interface{}, gonetworkmanager.Device) (gonetworkmanager.ActiveConnection, error)); ok {
		return returnFunc(connection, device)
	}
	if returnFunc, ok := ret.Get(0).(func(map[string]map[string]interface{}, gonetworkmanager.Device) gonetworkmanager.ActiveConnection); ok {
		r0 = returnFunc(connection, device)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(gonetworkmanager.ActiveConnection)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(map[string]map[string]interface{}, gonetworkmanager.Device) error); ok {
		r1 = returnFunc(connection, device)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_AddAndActivateConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAndActivateConnection'
type MockNetworkManager_AddAndActivateConnection_Call struct {
	*mock.Call
}

// AddAndActivateConnection is a helper method to define mock.On call
//   - connection map[string]map[string]interface{}
//   - device gonetworkmanager.Device
func (_e *MockNetworkManager_Expecter) AddAndActivateConnection(connection any, device any) *MockNetworkManager_AddAndActivateConnection_Call {
	return &MockNetworkManager_AddAndActivateConnection_Call{Call: _e.mock.On("AddAndActivateConnection", connection, device)}
}

func (_c *MockNetworkManager_AddAndActivateConnection_Call) Run(run func(connection map[string]map[string]interface{}, device gonetworkmanager.Device)) *MockNetworkManager_AddAndActivateConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 map[string]map[string]interface{}
		if args[0] != nil {
			arg0 = args[0].(map[string]map[string]interface{})
		}
		var arg1 gonetworkmanager.Device
		if args[1] != nil {
			arg1 = args[1].(gonetworkmanager.Device)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockNetworkManager_AddAndActivateConnection_Call) Return(activeConnection gonetworkmanager.ActiveConnection, err error) *MockNetworkManager_AddAndActivateConnection_Call {
	_c.Call.Return(activeConnection, err)
	return _c
}

func (_c *MockNetworkManager_AddAndActivateConnection_Call) RunAndReturn(run func(connection map[string]map[string]interface{}, device gonetworkmanager.Device) (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_AddAndActivateConnection_Call {
	_c.Call.Return(run)
	return _c
}

// AddAndActivateWirelessConnection provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) AddAndActivateWirelessConnection(connection map[string]map[string]interface{}, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error) {
	ret := _mock.Called(connection, device, accessPoint)

	if len(ret) == 0 {
		panic("no return value specified for AddAndActivateWirelessConnection")
	}

	var r0 gonetworkmanager.ActiveConnection
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(map[string]map[string]interface{}, gonetworkmanager.Device, gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error)); ok {
		return returnFunc(connection, device, accessPoint)
	}
	if returnFunc, ok := ret.Get(0).(func(map[string]map[string]interface{}, gonetworkmanager.Device, gonetworkmanager.AccessPoint) gonetworkmanager.ActiveConnection); ok {
		r0 = returnFunc(connection, device, accessPoint)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(gonetworkmanager.ActiveConnection)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(map[string]map[string]interface{}, gonetworkmanager.Device, gonetworkmanager.AccessPoint) error); ok {
		r1 = returnFunc(connection, device, accessPoint)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_AddAndActivateWirelessConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAndActivateWirelessConnection'
type MockNetworkManager_AddAndActivateWirelessConnection_Call struct {
	*mock.Call
}

// AddAndActivateWirelessConnection is a helper method to define mock.On call
//   - connection map[string]map[string]interface{}
//   - device gonetworkmanager.Device
//   - accessPoint gonetworkmanager.AccessPoint
func (_e *MockNetworkManager_Expecter) AddAndActivateWirelessConnection(connection any, device any, accessPoint any) *MockNetworkManager_AddAndActivateWirelessConnection_Call {
	return &MockNetworkManager_AddAndActivateWirelessConnection_Call{Call: _e.mock.On("AddAndActivateWirelessConnection", connection, device, accessPoint)}
}

func (_c *MockNetworkManager_AddAndActivateWirelessConnection_Call) Run(run func(connection map[string]map[string]interface{}, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint)) *MockNetworkManager_AddAndActivateWirelessConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 map[string]map[string]interface{}
		if args[0] != nil {
			arg0 = args[0].(map[string]map[string]interface{})
		}
		var arg1 gonetworkmanager.Device
		if args[1] != nil {
			arg1 = args[1].(gonetworkmanager.Device)
		}
		var arg2 gonetworkmanager.AccessPoint
		if args[2] != nil {
			arg2 = args[2].(gonetworkmanager.AccessPoint)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockNetworkManager_AddAndActivateWirelessConnection_Call) Return(activeConnection gonetworkmanager.ActiveConnection, err error) *MockNetworkManager_AddAndActivateWirelessConnection_Call {
	_c.Call.Return(activeConnection, err)
	return _c
}

func (_c *MockNetworkManager_AddAndActivateWirelessConnection_Call) RunAndReturn(run func(connection map[string]map[string]interface{}, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_AddAndActivateWirelessConnection_Call {
	_c.Call.Return(run)
	return _c
}

// CheckConnectivity provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) CheckConnectivity() error {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for CheckConnectivity")
	}

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

// MockNetworkManager_CheckConnectivity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckConnectivity'
type MockNetworkManager_CheckConnectivity_Call struct {
	*mock.Call
}

// CheckConnectivity is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) CheckConnectivity() *MockNetworkManager_CheckConnectivity_Call {
	return &MockNetworkManager_CheckConnectivity_Call{Call: _e.mock.On("CheckConnectivity")}
}

func (_c *MockNetworkManager_CheckConnectivity_Call) Run(run func()) *MockNetworkManager_CheckConnectivity_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_CheckConnectivity_Call) Return(err error) *MockNetworkManager_CheckConnectivity_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockNetworkManager_CheckConnectivity_Call) RunAndReturn(run func() error) *MockNetworkManager_CheckConnectivity_Call {
	_c.Call.Return(run)
	return _c
}

// CheckpointAdjustRollbackTimeout provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) CheckpointAdjustRollbackTimeout(checkpoint gonetworkmanager.Checkpoint, addTimeout uint32) error {
	ret := _mock.Called(checkpoint, addTimeout)

	if len(ret) == 0 {
		panic("no return value specified for CheckpointAdjustRollbackTimeout")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(gonetworkmanager.Checkpoint, uint32) error); ok {
		r0 = returnFunc(checkpoint, addTimeout)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockNetworkManager_CheckpointAdjustRollbackTimeout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckpointAdjustRollbackTimeout'
type MockNetworkManager_CheckpointAdjustRollbackTimeout_Call struct {
	*mock.Call
}

// CheckpointAdjustRollbackTimeout is a helper method to define mock.On call
//   - checkpoint gonetworkmanager.Checkpoint
//   - addTimeout uint32
func (_e *MockNetworkManager_Expecter) CheckpointAdjustRollbackTimeout(checkpoint any, addTimeout any) *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call {
	return &MockNetworkManager_CheckpointAdjustRollbackTimeout_Call{Call: _e.mock.On("CheckpointAdjustRollbackTimeout", checkpoint, addTimeout)}
}

func (_c *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call) Run(run func(checkpoint gonetworkmanager.Checkpoint, addTimeout uint32)) *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gonetworkmanager.Checkpoint
		if args[0] != nil {
			arg0 = args[0].(gonetworkmanager.Checkpoint)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call) Return(err error) *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call) RunAndReturn(run func(checkpoint gonetworkmanager.Checkpoint, addTimeout uint32) error) *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call {
	_c.Call.Return(run)
	return _c
}

// CheckpointCreate provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) CheckpointCreate(devices []gonetworkmanager.Device, rollbackTimeout uint32, flags uint32) (gonetworkmanager.Checkpoint, error) {
	ret := _mock.Called(devices, rollbackTimeout, flags)

	if len(ret) == 0 {
		panic("no return value specified for CheckpointCreate")
	}

	var r0 gonetworkmanager.Checkpoint
	var r1 error
	if returnFunc, ok := ret.Get(0).(func([]gonetworkmanager.Device, uint32, uint32) (gonetworkmanager.Checkpoint, error)); ok {
		return returnFunc(devices, rollbackTimeout, flags)
	}
	if returnFunc, ok := ret.Get(0).(func([]gonetworkmanager.Device, uint32, uint32) gonetworkmanager.Checkpoint); ok {
		r0 = returnFunc(devices, rollbackTimeout, flags)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(gonetworkmanager.Checkpoint)
		}
	}
	if returnFunc, ok := ret.Get(1).(func([]gonetworkmanager.Device, uint32, uint32) error); ok {
		r1 = returnFunc(devices, rollbackTimeout, flags)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_CheckpointCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckpointCreate'
type MockNetworkManager_CheckpointCreate_Call struct {
	*mock.Call
}

// CheckpointCreate is a helper method to define mock.On call
//   - devices []gonetworkmanager.Device
//   - rollbackTimeout uint32
//   - flags uint32
func (_e *MockNetworkManager_Expecter) CheckpointCreate(devices any, rollbackTimeout any, flags any) *MockNetworkManager_CheckpointCreate_Call {
	return &MockNetworkManager_CheckpointCreate_Call{Call: _e.mock.On("CheckpointCreate", devices, rollbackTimeout, flags)}
}

func (_c *MockNetworkManager_CheckpointCreate_Call) Run(run func(devices []gonetworkmanager.Device, rollbackTimeout uint32, flags uint32)) *MockNetworkManager_CheckpointCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []gonetworkmanager.Device
		if args[0] != nil {
			arg0 = args[0].([]gonetworkmanager.Device)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 uint32
		if args[2] != nil {
			arg2 = args[2].(uint32)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockNetworkManager_CheckpointCreate_Call) Return(checkpoint gonetworkmanager.Checkpoint, err error) *MockNetworkManager_CheckpointCreate_Call {
	_c.Call.Return(checkpoint, err)
	return _c
}

func (_c *MockNetworkManager_CheckpointCreate_Call) RunAndReturn(run func(devices []gonetworkmanager.Device, rollbackTimeout uint32, flags uint32) (gonetworkmanager.Checkpoint, error)) *MockNetworkManager_CheckpointCreate_Call {
	_c.Call.Return(run)
	return _c
}

// CheckpointDestroy provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) CheckpointDestroy(checkpoint gonetworkmanager.Checkpoint) error {
	ret := _mock.Called(checkpoint)

	if len(ret) == 0 {
		panic("no return value specified for CheckpointDestroy")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(gonetworkmanager.Checkpoint) error); ok {
		r0 = returnFunc(checkpoint)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockNetworkManager_CheckpointDestroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckpointDestroy'
type MockNetworkManager_CheckpointDestroy_Call struct {
	*mock.Call
}

// CheckpointDestroy is a helper method to define mock.On call
//   - checkpoint gonetworkmanager.Checkpoint
func (_e *MockNetworkManager_Expecter) CheckpointDestroy(checkpoint any) *MockNetworkManager_CheckpointDestroy_Call {
	return &MockNetworkManager_CheckpointDestroy_Call{Call: _e.mock.On("CheckpointDestroy", checkpoint)}
}

func (_c *MockNetworkManager_CheckpointDestroy_Call) Run(run func(checkpoint gonetworkmanager.Checkpoint)) *MockNetworkManager_CheckpointDestroy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gonetworkmanager.Checkpoint
		if args[0] != nil {
			arg0 = args[0].(gonetworkmanager.Checkpoint)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockNetworkManager_CheckpointDestroy_Call) Return(err error) *MockNetworkManager_CheckpointDestroy_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockNetworkManager_CheckpointDestroy_Call) RunAndReturn(run func(checkpoint gonetworkmanager.Checkpoint) error) *MockNetworkManager_CheckpointDestroy_Call {
	_c.Call.Return(run)
	return _c
}

// CheckpointRollback provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) CheckpointRollback(checkpoint gonetworkmanager.Checkpoint) (map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult, error) {
	ret := _mock.Called(checkpoint)

	if len(ret) == 0 {
		panic("no return value specified for CheckpointRollback")
	}

	var r0 map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(gonetworkmanager.Checkpoint) (map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult, error)); ok {
		return returnFunc(checkpoint)
	}
	if returnFunc, ok := ret.Get(0).(func(gonetworkmanager.Checkpoint) map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult); ok {
		r0 = returnFunc(checkpoint)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(gonetworkmanager.Checkpoint) error); ok {
		r1 = returnFunc(checkpoint)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_CheckpointRollback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckpointRollback'
type MockNetworkManager_CheckpointRollback_Call struct {
	*mock.Call
}

// CheckpointRollback is a helper method to define mock.On call
//   - checkpoint gonetworkmanager.Checkpoint
func (_e *MockNetworkManager_Expecter) CheckpointRollback(checkpoint any) *MockNetworkManager_CheckpointRollback_Call {
	return &MockNetworkManager_CheckpointRollback_Call{Call: _e.mock.On("CheckpointRollback", checkpoint)}
}

func (_c *MockNetworkManager_CheckpointRollback_Call) Run(run func(checkpoint gonetworkmanager.Checkpoint)) *MockNetworkManager_CheckpointRollback_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gonetworkmanager.Checkpoint
		if args[0] != nil {
			arg0 = args[0].(gonetworkmanager.Checkpoint)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockNetworkManager_CheckpointRollback_Call) Return(result map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult, err error) *MockNetworkManager_CheckpointRollback_Call {
	_c.Call.Return(result, err)
	return _c
}

func (_c *MockNetworkManager_CheckpointRollback_Call) RunAndReturn(run func(checkpoint gonetworkmanager.Checkpoint) (map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult, error)) *MockNetworkManager_CheckpointRollback_Call {
	_c.Call.Return(run)
	return _c
}

// DeactivateConnection provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) DeactivateConnection(connection gonetworkmanager.ActiveConnection) error {
	ret := _mock.Called(connection)

	if len(ret) == 0 {
		panic("no return value specified for DeactivateConnection")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(gonetworkmanager.ActiveConnection) error); ok {
		r0 = returnFunc(connection)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockNetworkManager_DeactivateConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeactivateConnection'
type MockNetworkManager_DeactivateConnection_Call struct {
	*mock.Call
}

// DeactivateConnection is a helper method to define mock.On call
//   - connection gonetworkmanager.ActiveConnection
func (_e *MockNetworkManager_Expecter) DeactivateConnection(connection any) *MockNetworkManager_DeactivateConnection_Call {
	return &MockNetworkManager_DeactivateConnection_Call{Call: _e.mock.On("DeactivateConnection", connection)}
}

func (_c *MockNetworkManager_DeactivateConnection_Call) Run(run func(connection gonetworkmanager.ActiveConnection)) *MockNetworkManager_DeactivateConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gonetworkmanager.ActiveConnection
		if args[0] != nil {
			arg0 = args[0].(gonetworkmanager.ActiveConnection)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockNetworkManager_DeactivateConnection_Call) Return(err error) *MockNetworkManager_DeactivateConnection_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockNetworkManager_DeactivateConnection_Call) RunAndReturn(run func(connection gonetworkmanager.ActiveConnection) error) *MockNetworkManager_DeactivateConnection_Call {
	_c.Call.Return(run)
	return _c
}

// Enable provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) Enable(enableNDisable bool) error {
	ret := _mock.Called(enableNDisable)

	if len(ret) == 0 {
		panic("no return value specified for Enable")
	}

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

// MockNetworkManager_Enable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Enable'
type MockNetworkManager_Enable_Call struct {
	*mock.Call
}

// Enable is a helper method to define mock.On call
//   - enableNDisable bool
func (_e *MockNetworkManager_Expecter) Enable(enableNDisable any) *MockNetworkManager_Enable_Call {
	return &MockNetworkManager_Enable_Call{Call: _e.mock.On("Enable", enableNDisable)}
}

func (_c *MockNetworkManager_Enable_Call) Run(run func(enableNDisable bool)) *MockNetworkManager_Enable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockNetworkManager_Enable_Call) Return(err error) *MockNetworkManager_Enable_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockNetworkManager_Enable_Call) RunAndReturn(run func(enableNDisable bool) error) *MockNetworkManager_Enable_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllDevices provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetAllDevices() ([]gonetworkmanager.Device, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllDevices")
	}

	var r0 []gonetworkmanager.Device
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]gonetworkmanager.Device)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetAllDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllDevices'
type MockNetworkManager_GetAllDevices_Call struct {
	*mock.Call
}

// GetAllDevices is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetAllDevices() *MockNetworkManager_GetAllDevices_Call {
	return &MockNetworkManager_GetAllDevices_Call{Call: _e.mock.On("GetAllDevices")}
}

func (_c *MockNetworkManager_GetAllDevices_Call) Run(run func()) *MockNetworkManager_GetAllDevices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetAllDevices_Call) Return(devices []gonetworkmanager.Device, err error) *MockNetworkManager_GetAllDevices_Call {
	_c.Call.Return(devices, err)
	return _c
}

func (_c *MockNetworkManager_GetAllDevices_Call) RunAndReturn(run func() ([]gonetworkmanager.Device, error)) *MockNetworkManager_GetAllDevices_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeviceByIpIface provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetDeviceByIpIface(interfaceId string) (gonetworkmanager.Device, error) {
	ret := _mock.Called(interfaceId)

	if len(ret) == 0 {
		panic("no return value specified for GetDeviceByIpIface")
	}

	var r0 gonetworkmanager.Device
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string) (gonetworkmanager.Device, error)); ok {
		return returnFunc(interfaceId)
	}
	if returnFunc, ok := ret.Get(0).(func(string) gonetworkmanager.Device); ok {
		r0 = returnFunc(interfaceId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(gonetworkmanager.Device)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
		r1 = returnFunc(interfaceId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetDeviceByIpIface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDeviceByIpIface'
type MockNetworkManager_GetDeviceByIpIface_Call struct {
	*mock.Call
}

// GetDeviceByIpIface is a helper method to define mock.On call
//   - interfaceId string
func (_e *MockNetworkManager_Expecter) GetDeviceByIpIface(interfaceId any) *MockNetworkManager_GetDeviceByIpIface_Call {
	return &MockNetworkManager_GetDeviceByIpIface_Call{Call: _e.mock.On("GetDeviceByIpIface", interfaceId)}
}

func (_c *MockNetworkManager_GetDeviceByIpIface_Call) Run(run func(interfaceId string)) *MockNetworkManager_GetDeviceByIpIface_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockNetworkManager_GetDeviceByIpIface_Call) Return(device gonetworkmanager.Device, err error) *MockNetworkManager_GetDeviceByIpIface_Call {
	_c.Call.Return(device, err)
	return _c
}

func (_c *MockNetworkManager_GetDeviceByIpIface_Call) RunAndReturn(run func(interfaceId string) (gonetworkmanager.Device, error)) *MockNetworkManager_GetDeviceByIpIface_Call {
	_c.Call.Return(run)
	return _c
}

// GetDevices provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetDevices() ([]gonetworkmanager.Device, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetDevices")
	}

	var r0 []gonetworkmanager.Device
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]gonetworkmanager.Device)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDevices'
type MockNetworkManager_GetDevices_Call struct {
	*mock.Call
}

// GetDevices is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetDevices() *MockNetworkManager_GetDevices_Call {
	return &MockNetworkManager_GetDevices_Call{Call: _e.mock.On("GetDevices")}
}

func (_c *MockNetworkManager_GetDevices_Call) Run(run func()) *MockNetworkManager_GetDevices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetDevices_Call) Return(devices []gonetworkmanager.Device, err error) *MockNetworkManager_GetDevices_Call {
	_c.Call.Return(devices, err)
	return _c
}

func (_c *MockNetworkManager_GetDevices_Call) RunAndReturn(run func() ([]gonetworkmanager.Device, error)) *MockNetworkManager_GetDevices_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyActivatingConnection provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyActivatingConnection() (gonetworkmanager.ActiveConnection, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyActivatingConnection")
	}

	var r0 gonetworkmanager.ActiveConnection
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.ActiveConnection, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.ActiveConnection); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(gonetworkmanager.ActiveConnection)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyActivatingConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyActivatingConnection'
type MockNetworkManager_GetPropertyActivatingConnection_Call struct {
	*mock.Call
}

// GetPropertyActivatingConnection is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyActivatingConnection() *MockNetworkManager_GetPropertyActivatingConnection_Call {
	return &MockNetworkManager_GetPropertyActivatingConnection_Call{Call: _e.mock.On("GetPropertyActivatingConnection")}
}

func (_c *MockNetworkManager_GetPropertyActivatingConnection_Call) Run(run func()) *MockNetworkManager_GetPropertyActivatingConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyActivatingConnection_Call) Return(activeConnection gonetworkmanager.ActiveConnection, err error) *MockNetworkManager_GetPropertyActivatingConnection_Call {
	_c.Call.Return(activeConnection, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyActivatingConnection_Call) RunAndReturn(run func() (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_GetPropertyActivatingConnection_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyActiveConnections provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyActiveConnections() ([]gonetworkmanager.ActiveConnection, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyActiveConnections")
	}

	var r0 []gonetworkmanager.ActiveConnection
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() ([]gonetworkmanager.ActiveConnection, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() []gonetworkmanager.ActiveConnection); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]gonetworkmanager.ActiveConnection)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyActiveConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyActiveConnections'
type MockNetworkManager_GetPropertyActiveConnections_Call struct {
	*mock.Call
}

// GetPropertyActiveConnections is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyActiveConnections() *MockNetworkManager_GetPropertyActiveConnections_Call {
	return &MockNetworkManager_GetPropertyActiveConnections_Call{Call: _e.mock.On("GetPropertyActiveConnections")}
}

func (_c *MockNetworkManager_GetPropertyActiveConnections_Call) Run(run func()) *MockNetworkManager_GetPropertyActiveConnections_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyActiveConnections_Call) Return(activeConnections []gonetworkmanager.ActiveConnection, err error) *MockNetworkManager_GetPropertyActiveConnections_Call {
	_c.Call.Return(activeConnections, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyActiveConnections_Call) RunAndReturn(run func() ([]gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_GetPropertyActiveConnections_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyAllDevices provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyAllDevices() ([]gonetworkmanager.Device, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyAllDevices")
	}

	var r0 []gonetworkmanager.Device
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]gonetworkmanager.Device)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyAllDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAllDevices'
type MockNetworkManager_GetPropertyAllDevices_Call struct {
	*mock.Call
}

// GetPropertyAllDevices is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyAllDevices() *MockNetworkManager_GetPropertyAllDevices_Call {
	return &MockNetworkManager_GetPropertyAllDevices_Call{Call: _e.mock.On("GetPropertyAllDevices")}
}

func (_c *MockNetworkManager_GetPropertyAllDevices_Call) Run(run func()) *MockNetworkManager_GetPropertyAllDevices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyAllDevices_Call) Return(devices []gonetworkmanager.Device, err error) *MockNetworkManager_GetPropertyAllDevices_Call {
	_c.Call.Return(devices, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyAllDevices_Call) RunAndReturn(run func() ([]gonetworkmanager.Device, error)) *MockNetworkManager_GetPropertyAllDevices_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyCapabilities provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyCapabilities() ([]gonetworkmanager.NmCapability, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyCapabilities")
	}

	var r0 []gonetworkmanager.NmCapability
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() ([]gonetworkmanager.NmCapability, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() []gonetworkmanager.NmCapability); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]gonetworkmanager.NmCapability)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyCapabilities_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyCapabilities'
type MockNetworkManager_GetPropertyCapabilities_Call struct {
	*mock.Call
}

// GetPropertyCapabilities is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyCapabilities() *MockNetworkManager_GetPropertyCapabilities_Call {
	return &MockNetworkManager_GetPropertyCapabilities_Call{Call: _e.mock.On("GetPropertyCapabilities")}
}

func (_c *MockNetworkManager_GetPropertyCapabilities_Call) Run(run func()) *MockNetworkManager_GetPropertyCapabilities_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyCapabilities_Call) Return(nmCapabilitys []gonetworkmanager.NmCapability, err error) *MockNetworkManager_GetPropertyCapabilities_Call {
	_c.Call.Return(nmCapabilitys, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyCapabilities_Call) RunAndReturn(run func() ([]gonetworkmanager.NmCapability, error)) *MockNetworkManager_GetPropertyCapabilities_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyCheckpoints provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyCheckpoints() ([]gonetworkmanager.Checkpoint, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyCheckpoints")
	}

	var r0 []gonetworkmanager.Checkpoint
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() ([]gonetworkmanager.Checkpoint, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() []gonetworkmanager.Checkpoint); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]gonetworkmanager.Checkpoint)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyCheckpoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyCheckpoints'
type MockNetworkManager_GetPropertyCheckpoints_Call struct {
	*mock.Call
}

// GetPropertyCheckpoints is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyCheckpoints() *MockNetworkManager_GetPropertyCheckpoints_Call {
	return &MockNetworkManager_GetPropertyCheckpoints_Call{Call: _e.mock.On("GetPropertyCheckpoints")}
}

func (_c *MockNetworkManager_GetPropertyCheckpoints_Call) Run(run func()) *MockNetworkManager_GetPropertyCheckpoints_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyCheckpoints_Call) Return(checkpoints []gonetworkmanager.Checkpoint, err error) *MockNetworkManager_GetPropertyCheckpoints_Call {
	_c.Call.Return(checkpoints, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyCheckpoints_Call) RunAndReturn(run func() ([]gonetworkmanager.Checkpoint, error)) *MockNetworkManager_GetPropertyCheckpoints_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyConnectivity provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyConnectivity() (gonetworkmanager.NmConnectivity, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyConnectivity")
	}

	var r0 gonetworkmanager.NmConnectivity
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.NmConnectivity, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.NmConnectivity); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(gonetworkmanager.NmConnectivity)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyConnectivity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyConnectivity'
type MockNetworkManager_GetPropertyConnectivity_Call struct {
	*mock.Call
}

// GetPropertyConnectivity is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyConnectivity() *MockNetworkManager_GetPropertyConnectivity_Call {
	return &MockNetworkManager_GetPropertyConnectivity_Call{Call: _e.mock.On("GetPropertyConnectivity")}
}

func (_c *MockNetworkManager_GetPropertyConnectivity_Call) Run(run func()) *MockNetworkManager_GetPropertyConnectivity_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyConnectivity_Call) Return(nmConnectivity gonetworkmanager.NmConnectivity, err error) *MockNetworkManager_GetPropertyConnectivity_Call {
	_c.Call.Return(nmConnectivity, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyConnectivity_Call) RunAndReturn(run func() (gonetworkmanager.NmConnectivity, error)) *MockNetworkManager_GetPropertyConnectivity_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyConnectivityCheckAvailable provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyConnectivityCheckAvailable() (bool, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyConnectivityCheckAvailable")
	}

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyConnectivityCheckAvailable'
type MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call struct {
	*mock.Call
}

// GetPropertyConnectivityCheckAvailable is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyConnectivityCheckAvailable() *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call {
	return &MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call{Call: _e.mock.On("GetPropertyConnectivityCheckAvailable")}
}

func (_c *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call) Run(run func()) *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call) Return(b bool, err error) *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyConnectivityCheckEnabled provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyConnectivityCheckEnabled() (bool, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyConnectivityCheckEnabled")
	}

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyConnectivityCheckEnabled'
type MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call struct {
	*mock.Call
}

// GetPropertyConnectivityCheckEnabled is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyConnectivityCheckEnabled() *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call {
	return &MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call{Call: _e.mock.On("GetPropertyConnectivityCheckEnabled")}
}

func (_c *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call) Return(b bool, err error) *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyDevices provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyDevices() ([]gonetworkmanager.Device, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyDevices")
	}

	var r0 []gonetworkmanager.Device
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]gonetworkmanager.Device)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDevices'
type MockNetworkManager_GetPropertyDevices_Call struct {
	*mock.Call
}

// GetPropertyDevices is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyDevices() *MockNetworkManager_GetPropertyDevices_Call {
	return &MockNetworkManager_GetPropertyDevices_Call{Call: _e.mock.On("GetPropertyDevices")}
}

func (_c *MockNetworkManager_GetPropertyDevices_Call) Run(run func()) *MockNetworkManager_GetPropertyDevices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyDevices_Call) Return(devices []gonetworkmanager.Device, err error) *MockNetworkManager_GetPropertyDevices_Call {
	_c.Call.Return(devices, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyDevices_Call) RunAndReturn(run func() ([]gonetworkmanager.Device, error)) *MockNetworkManager_GetPropertyDevices_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyMetered provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyMetered() (gonetworkmanager.NmMetered, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyMetered")
	}

	var r0 gonetworkmanager.NmMetered
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.NmMetered, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.NmMetered); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(gonetworkmanager.NmMetered)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyMetered_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyMetered'
type MockNetworkManager_GetPropertyMetered_Call struct {
	*mock.Call
}

// GetPropertyMetered is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyMetered() *MockNetworkManager_GetPropertyMetered_Call {
	return &MockNetworkManager_GetPropertyMetered_Call{Call: _e.mock.On("GetPropertyMetered")}
}

func (_c *MockNetworkManager_GetPropertyMetered_Call) Run(run func()) *MockNetworkManager_GetPropertyMetered_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyMetered_Call) Return(nmMetered gonetworkmanager.NmMetered, err error) *MockNetworkManager_GetPropertyMetered_Call {
	_c.Call.Return(nmMetered, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyMetered_Call) RunAndReturn(run func() (gonetworkmanager.NmMetered, error)) *MockNetworkManager_GetPropertyMetered_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyNetworkingEnabled provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyNetworkingEnabled() (bool, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyNetworkingEnabled")
	}

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyNetworkingEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyNetworkingEnabled'
type MockNetworkManager_GetPropertyNetworkingEnabled_Call struct {
	*mock.Call
}

// GetPropertyNetworkingEnabled is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyNetworkingEnabled() *MockNetworkManager_GetPropertyNetworkingEnabled_Call {
	return &MockNetworkManager_GetPropertyNetworkingEnabled_Call{Call: _e.mock.On("GetPropertyNetworkingEnabled")}
}

func (_c *MockNetworkManager_GetPropertyNetworkingEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyNetworkingEnabled_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyNetworkingEnabled_Call) Return(b bool, err error) *MockNetworkManager_GetPropertyNetworkingEnabled_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyNetworkingEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyNetworkingEnabled_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyPrimaryConnection provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyPrimaryConnection() (gonetworkmanager.ActiveConnection, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyPrimaryConnection")
	}

	var r0 gonetworkmanager.ActiveConnection
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.ActiveConnection, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.ActiveConnection); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(gonetworkmanager.ActiveConnection)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyPrimaryConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyPrimaryConnection'
type MockNetworkManager_GetPropertyPrimaryConnection_Call struct {
	*mock.Call
}

// GetPropertyPrimaryConnection is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyPrimaryConnection() *MockNetworkManager_GetPropertyPrimaryConnection_Call {
	return &MockNetworkManager_GetPropertyPrimaryConnection_Call{Call: _e.mock.On("GetPropertyPrimaryConnection")}
}

func (_c *MockNetworkManager_GetPropertyPrimaryConnection_Call) Run(run func()) *MockNetworkManager_GetPropertyPrimaryConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyPrimaryConnection_Call) Return(activeConnection gonetworkmanager.ActiveConnection, err error) *MockNetworkManager_GetPropertyPrimaryConnection_Call {
	_c.Call.Return(activeConnection, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyPrimaryConnection_Call) RunAndReturn(run func() (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_GetPropertyPrimaryConnection_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyPrimaryConnectionType provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyPrimaryConnectionType() (string, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyPrimaryConnectionType")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyPrimaryConnectionType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyPrimaryConnectionType'
type MockNetworkManager_GetPropertyPrimaryConnectionType_Call struct {
	*mock.Call
}

// GetPropertyPrimaryConnectionType is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyPrimaryConnectionType() *MockNetworkManager_GetPropertyPrimaryConnectionType_Call {
	return &MockNetworkManager_GetPropertyPrimaryConnectionType_Call{Call: _e.mock.On("GetPropertyPrimaryConnectionType")}
}

func (_c *MockNetworkManager_GetPropertyPrimaryConnectionType_Call) Run(run func()) *MockNetworkManager_GetPropertyPrimaryConnectionType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyPrimaryConnectionType_Call) Return(s string, err error) *MockNetworkManager_GetPropertyPrimaryConnectionType_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyPrimaryConnectionType_Call) RunAndReturn(run func() (string, error)) *MockNetworkManager_GetPropertyPrimaryConnectionType_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyStartup provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyStartup() (bool, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyStartup")
	}

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyStartup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyStartup'
type MockNetworkManager_GetPropertyStartup_Call struct {
	*mock.Call
}

// GetPropertyStartup is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyStartup() *MockNetworkManager_GetPropertyStartup_Call {
	return &MockNetworkManager_GetPropertyStartup_Call{Call: _e.mock.On("GetPropertyStartup")}
}

func (_c *MockNetworkManager_GetPropertyStartup_Call) Run(run func()) *MockNetworkManager_GetPropertyStartup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyStartup_Call) Return(b bool, err error) *MockNetworkManager_GetPropertyStartup_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyStartup_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyStartup_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyState provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyState() (gonetworkmanager.NmState, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyState")
	}

	var r0 gonetworkmanager.NmState
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.NmState, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.NmState); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(gonetworkmanager.NmState)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyState'
type MockNetworkManager_GetPropertyState_Call struct {
	*mock.Call
}

// GetPropertyState is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyState() *MockNetworkManager_GetPropertyState_Call {
	return &MockNetworkManager_GetPropertyState_Call{Call: _e.mock.On("GetPropertyState")}
}

func (_c *MockNetworkManager_GetPropertyState_Call) Run(run func()) *MockNetworkManager_GetPropertyState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyState_Call) Return(nmState gonetworkmanager.NmState, err error) *MockNetworkManager_GetPropertyState_Call {
	_c.Call.Return(nmState, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyState_Call) RunAndReturn(run func() (gonetworkmanager.NmState, error)) *MockNetworkManager_GetPropertyState_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyVersion provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyVersion() (string, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyVersion")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyVersion'
type MockNetworkManager_GetPropertyVersion_Call struct {
	*mock.Call
}

// GetPropertyVersion is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyVersion() *MockNetworkManager_GetPropertyVersion_Call {
	return &MockNetworkManager_GetPropertyVersion_Call{Call: _e.mock.On("GetPropertyVersion")}
}

func (_c *MockNetworkManager_GetPropertyVersion_Call) Run(run func()) *MockNetworkManager_GetPropertyVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyVersion_Call) Return(s string, err error) *MockNetworkManager_GetPropertyVersion_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyVersion_Call) RunAndReturn(run func() (string, error)) *MockNetworkManager_GetPropertyVersion_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyWimaxEnabled provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyWimaxEnabled() (bool, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyWimaxEnabled")
	}

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyWimaxEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWimaxEnabled'
type MockNetworkManager_GetPropertyWimaxEnabled_Call struct {
	*mock.Call
}

// GetPropertyWimaxEnabled is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyWimaxEnabled() *MockNetworkManager_GetPropertyWimaxEnabled_Call {
	return &MockNetworkManager_GetPropertyWimaxEnabled_Call{Call: _e.mock.On("GetPropertyWimaxEnabled")}
}

func (_c *MockNetworkManager_GetPropertyWimaxEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWimaxEnabled_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyWimaxEnabled_Call) Return(b bool, err error) *MockNetworkManager_GetPropertyWimaxEnabled_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyWimaxEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWimaxEnabled_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyWimaxHardwareEnabled provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyWimaxHardwareEnabled() (bool, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyWimaxHardwareEnabled")
	}

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWimaxHardwareEnabled'
type MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call struct {
	*mock.Call
}

// GetPropertyWimaxHardwareEnabled is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyWimaxHardwareEnabled() *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call {
	return &MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call{Call: _e.mock.On("GetPropertyWimaxHardwareEnabled")}
}

func (_c *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call) Return(b bool, err error) *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyWirelessEnabled provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyWirelessEnabled() (bool, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyWirelessEnabled")
	}

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyWirelessEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWirelessEnabled'
type MockNetworkManager_GetPropertyWirelessEnabled_Call struct {
	*mock.Call
}

// GetPropertyWirelessEnabled is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyWirelessEnabled() *MockNetworkManager_GetPropertyWirelessEnabled_Call {
	return &MockNetworkManager_GetPropertyWirelessEnabled_Call{Call: _e.mock.On("GetPropertyWirelessEnabled")}
}

func (_c *MockNetworkManager_GetPropertyWirelessEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWirelessEnabled_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyWirelessEnabled_Call) Return(b bool, err error) *MockNetworkManager_GetPropertyWirelessEnabled_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyWirelessEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWirelessEnabled_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyWirelessHardwareEnabled provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyWirelessHardwareEnabled() (bool, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyWirelessHardwareEnabled")
	}

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWirelessHardwareEnabled'
type MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call struct {
	*mock.Call
}

// GetPropertyWirelessHardwareEnabled is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyWirelessHardwareEnabled() *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call {
	return &MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call{Call: _e.mock.On("GetPropertyWirelessHardwareEnabled")}
}

func (_c *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call) Return(b bool, err error) *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyWwanEnabled provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyWwanEnabled() (bool, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyWwanEnabled")
	}

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyWwanEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWwanEnabled'
type MockNetworkManager_GetPropertyWwanEnabled_Call struct {
	*mock.Call
}

// GetPropertyWwanEnabled is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyWwanEnabled() *MockNetworkManager_GetPropertyWwanEnabled_Call {
	return &MockNetworkManager_GetPropertyWwanEnabled_Call{Call: _e.mock.On("GetPropertyWwanEnabled")}
}

func (_c *MockNetworkManager_GetPropertyWwanEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWwanEnabled_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyWwanEnabled_Call) Return(b bool, err error) *MockNetworkManager_GetPropertyWwanEnabled_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyWwanEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWwanEnabled_Call {
	_c.Call.Return(run)
	return _c
}

// GetPropertyWwanHardwareEnabled provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) GetPropertyWwanHardwareEnabled() (bool, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPropertyWwanHardwareEnabled")
	}

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_GetPropertyWwanHardwareEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWwanHardwareEnabled'
type MockNetworkManager_GetPropertyWwanHardwareEnabled_Call struct {
	*mock.Call
}

// GetPropertyWwanHardwareEnabled is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) GetPropertyWwanHardwareEnabled() *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call {
	return &MockNetworkManager_GetPropertyWwanHardwareEnabled_Call{Call: _e.mock.On("GetPropertyWwanHardwareEnabled")}
}

func (_c *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call) Return(b bool, err error) *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call {
	_c.Call.Return(run)
	return _c
}

// MarshalJSON provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) MarshalJSON() ([]byte, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for MarshalJSON")
	}

	var r0 []byte
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() ([]byte, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() []byte); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_MarshalJSON_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarshalJSON'
type MockNetworkManager_MarshalJSON_Call struct {
	*mock.Call
}

// MarshalJSON is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) MarshalJSON() *MockNetworkManager_MarshalJSON_Call {
	return &MockNetworkManager_MarshalJSON_Call{Call: _e.mock.On("MarshalJSON")}
}

func (_c *MockNetworkManager_MarshalJSON_Call) Run(run func()) *MockNetworkManager_MarshalJSON_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_MarshalJSON_Call) Return(bytes []byte, err error) *MockNetworkManager_MarshalJSON_Call {
	_c.Call.Return(bytes, err)
	return _c
}

func (_c *MockNetworkManager_MarshalJSON_Call) RunAndReturn(run func() ([]byte, error)) *MockNetworkManager_MarshalJSON_Call {
	_c.Call.Return(run)
	return _c
}

// Reload provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) Reload(flags uint32) error {
	ret := _mock.Called(flags)

	if len(ret) == 0 {
		panic("no return value specified for Reload")
	}

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

// MockNetworkManager_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
type MockNetworkManager_Reload_Call struct {
	*mock.Call
}

// Reload is a helper method to define mock.On call
//   - flags uint32
func (_e *MockNetworkManager_Expecter) Reload(flags any) *MockNetworkManager_Reload_Call {
	return &MockNetworkManager_Reload_Call{Call: _e.mock.On("Reload", flags)}
}

func (_c *MockNetworkManager_Reload_Call) Run(run func(flags uint32)) *MockNetworkManager_Reload_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 uint32
		if args[0] != nil {
			arg0 = args[0].(uint32)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockNetworkManager_Reload_Call) Return(err error) *MockNetworkManager_Reload_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockNetworkManager_Reload_Call) RunAndReturn(run func(flags uint32) error) *MockNetworkManager_Reload_Call {
	_c.Call.Return(run)
	return _c
}

// SetPropertyWirelessEnabled provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) SetPropertyWirelessEnabled(b bool) error {
	ret := _mock.Called(b)

	if len(ret) == 0 {
		panic("no return value specified for SetPropertyWirelessEnabled")
	}

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

// MockNetworkManager_SetPropertyWirelessEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPropertyWirelessEnabled'
type MockNetworkManager_SetPropertyWirelessEnabled_Call struct {
	*mock.Call
}

// SetPropertyWirelessEnabled is a helper method to define mock.On call
//   - b bool
func (_e *MockNetworkManager_Expecter) SetPropertyWirelessEnabled(b any) *MockNetworkManager_SetPropertyWirelessEnabled_Call {
	return &MockNetworkManager_SetPropertyWirelessEnabled_Call{Call: _e.mock.On("SetPropertyWirelessEnabled", b)}
}

func (_c *MockNetworkManager_SetPropertyWirelessEnabled_Call) Run(run func(b bool)) *MockNetworkManager_SetPropertyWirelessEnabled_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockNetworkManager_SetPropertyWirelessEnabled_Call) Return(err error) *MockNetworkManager_SetPropertyWirelessEnabled_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockNetworkManager_SetPropertyWirelessEnabled_Call) RunAndReturn(run func(b bool) error) *MockNetworkManager_SetPropertyWirelessEnabled_Call {
	_c.Call.Return(run)
	return _c
}

// Sleep provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) Sleep(sleepNWake bool) error {
	ret := _mock.Called(sleepNWake)

	if len(ret) == 0 {
		panic("no return value specified for Sleep")
	}

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

// MockNetworkManager_Sleep_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sleep'
type MockNetworkManager_Sleep_Call struct {
	*mock.Call
}

// Sleep is a helper method to define mock.On call
//   - sleepNWake bool
func (_e *MockNetworkManager_Expecter) Sleep(sleepNWake any) *MockNetworkManager_Sleep_Call {
	return &MockNetworkManager_Sleep_Call{Call: _e.mock.On("Sleep", sleepNWake)}
}

func (_c *MockNetworkManager_Sleep_Call) Run(run func(sleepNWake bool)) *MockNetworkManager_Sleep_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockNetworkManager_Sleep_Call) Return(err error) *MockNetworkManager_Sleep_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockNetworkManager_Sleep_Call) RunAndReturn(run func(sleepNWake bool) error) *MockNetworkManager_Sleep_Call {
	_c.Call.Return(run)
	return _c
}

// State provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) State() (gonetworkmanager.NmState, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for State")
	}

	var r0 gonetworkmanager.NmState
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.NmState, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.NmState); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(gonetworkmanager.NmState)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockNetworkManager_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State'
type MockNetworkManager_State_Call struct {
	*mock.Call
}

// State is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) State() *MockNetworkManager_State_Call {
	return &MockNetworkManager_State_Call{Call: _e.mock.On("State")}
}

func (_c *MockNetworkManager_State_Call) Run(run func()) *MockNetworkManager_State_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_State_Call) Return(nmState gonetworkmanager.NmState, err error) *MockNetworkManager_State_Call {
	_c.Call.Return(nmState, err)
	return _c
}

func (_c *MockNetworkManager_State_Call) RunAndReturn(run func() (gonetworkmanager.NmState, error)) *MockNetworkManager_State_Call {
	_c.Call.Return(run)
	return _c
}

// Subscribe provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) Subscribe() <-chan *dbus.Signal {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for Subscribe")
	}

	var r0 <-chan *dbus.Signal
	if returnFunc, ok := ret.Get(0).(func() <-chan *dbus.Signal); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan *dbus.Signal)
		}
	}
	return r0
}

// MockNetworkManager_Subscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Subscribe'
type MockNetworkManager_Subscribe_Call struct {
	*mock.Call
}

// Subscribe is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) Subscribe() *MockNetworkManager_Subscribe_Call {
	return &MockNetworkManager_Subscribe_Call{Call: _e.mock.On("Subscribe")}
}

func (_c *MockNetworkManager_Subscribe_Call) Run(run func()) *MockNetworkManager_Subscribe_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_Subscribe_Call) Return(signalCh <-chan *dbus.Signal) *MockNetworkManager_Subscribe_Call {
	_c.Call.Return(signalCh)
	return _c
}

func (_c *MockNetworkManager_Subscribe_Call) RunAndReturn(run func() <-chan *dbus.Signal) *MockNetworkManager_Subscribe_Call {
	_c.Call.Return(run)
	return _c
}

// Unsubscribe provides a mock function for the type MockNetworkManager
func (_mock *MockNetworkManager) Unsubscribe() {
	_mock.Called()
	return
}

// MockNetworkManager_Unsubscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unsubscribe'
type MockNetworkManager_Unsubscribe_Call struct {
	*mock.Call
}

// Unsubscribe is a helper method to define mock.On call
func (_e *MockNetworkManager_Expecter) Unsubscribe() *MockNetworkManager_Unsubscribe_Call {
	return &MockNetworkManager_Unsubscribe_Call{Call: _e.mock.On("Unsubscribe")}
}

func (_c *MockNetworkManager_Unsubscribe_Call) Run(run func()) *MockNetworkManager_Unsubscribe_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockNetworkManager_Unsubscribe_Call) Return() *MockNetworkManager_Unsubscribe_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockNetworkManager_Unsubscribe_Call) RunAndReturn(run func()) *MockNetworkManager_Unsubscribe_Call {
	_c.Run(run)
	return _c
}
