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

package mocks_network

import (
	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/network"
	mock "github.com/stretchr/testify/mock"
)

// NewMockBackend creates a new instance of MockBackend. 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 NewMockBackend(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBackend {
	mock := &MockBackend{}
	mock.Mock.Test(t)

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

	return mock
}

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

type MockBackend_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBackend) EXPECT() *MockBackend_Expecter {
	return &MockBackend_Expecter{mock: &_m.Mock}
}

// ActivateWiredConnection provides a mock function for the type MockBackend
func (_mock *MockBackend) ActivateWiredConnection(uuid string) error {
	ret := _mock.Called(uuid)

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

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

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

// ActivateWiredConnection is a helper method to define mock.On call
//   - uuid string
func (_e *MockBackend_Expecter) ActivateWiredConnection(uuid any) *MockBackend_ActivateWiredConnection_Call {
	return &MockBackend_ActivateWiredConnection_Call{Call: _e.mock.On("ActivateWiredConnection", uuid)}
}

func (_c *MockBackend_ActivateWiredConnection_Call) Run(run func(uuid string)) *MockBackend_ActivateWiredConnection_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 *MockBackend_ActivateWiredConnection_Call) Return(err error) *MockBackend_ActivateWiredConnection_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockBackend_ActivateWiredConnection_Call) RunAndReturn(run func(uuid string) error) *MockBackend_ActivateWiredConnection_Call {
	_c.Call.Return(run)
	return _c
}

// CancelCredentials provides a mock function for the type MockBackend
func (_mock *MockBackend) CancelCredentials(token string) error {
	ret := _mock.Called(token)

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

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

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

// CancelCredentials is a helper method to define mock.On call
//   - token string
func (_e *MockBackend_Expecter) CancelCredentials(token any) *MockBackend_CancelCredentials_Call {
	return &MockBackend_CancelCredentials_Call{Call: _e.mock.On("CancelCredentials", token)}
}

func (_c *MockBackend_CancelCredentials_Call) Run(run func(token string)) *MockBackend_CancelCredentials_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 *MockBackend_CancelCredentials_Call) Return(err error) *MockBackend_CancelCredentials_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockBackend_CancelCredentials_Call) RunAndReturn(run func(token string) error) *MockBackend_CancelCredentials_Call {
	_c.Call.Return(run)
	return _c
}

// ClearVPNCredentials provides a mock function for the type MockBackend
func (_mock *MockBackend) ClearVPNCredentials(uuidOrName string) error {
	ret := _mock.Called(uuidOrName)

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

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

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

// ClearVPNCredentials is a helper method to define mock.On call
//   - uuidOrName string
func (_e *MockBackend_Expecter) ClearVPNCredentials(uuidOrName any) *MockBackend_ClearVPNCredentials_Call {
	return &MockBackend_ClearVPNCredentials_Call{Call: _e.mock.On("ClearVPNCredentials", uuidOrName)}
}

func (_c *MockBackend_ClearVPNCredentials_Call) Run(run func(uuidOrName string)) *MockBackend_ClearVPNCredentials_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 *MockBackend_ClearVPNCredentials_Call) Return(err error) *MockBackend_ClearVPNCredentials_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockBackend_ClearVPNCredentials_Call) RunAndReturn(run func(uuidOrName string) error) *MockBackend_ClearVPNCredentials_Call {
	_c.Call.Return(run)
	return _c
}

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

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

// Close is a helper method to define mock.On call
func (_e *MockBackend_Expecter) Close() *MockBackend_Close_Call {
	return &MockBackend_Close_Call{Call: _e.mock.On("Close")}
}

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

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

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

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

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

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

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

// ConnectEthernet is a helper method to define mock.On call
func (_e *MockBackend_Expecter) ConnectEthernet() *MockBackend_ConnectEthernet_Call {
	return &MockBackend_ConnectEthernet_Call{Call: _e.mock.On("ConnectEthernet")}
}

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

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

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

// ConnectVPN provides a mock function for the type MockBackend
func (_mock *MockBackend) ConnectVPN(uuidOrName string, singleActive bool) error {
	ret := _mock.Called(uuidOrName, singleActive)

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

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

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

// ConnectVPN is a helper method to define mock.On call
//   - uuidOrName string
//   - singleActive bool
func (_e *MockBackend_Expecter) ConnectVPN(uuidOrName any, singleActive any) *MockBackend_ConnectVPN_Call {
	return &MockBackend_ConnectVPN_Call{Call: _e.mock.On("ConnectVPN", uuidOrName, singleActive)}
}

func (_c *MockBackend_ConnectVPN_Call) Run(run func(uuidOrName string, singleActive bool)) *MockBackend_ConnectVPN_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockBackend_ConnectVPN_Call) RunAndReturn(run func(uuidOrName string, singleActive bool) error) *MockBackend_ConnectVPN_Call {
	_c.Call.Return(run)
	return _c
}

// ConnectWiFi provides a mock function for the type MockBackend
func (_mock *MockBackend) ConnectWiFi(req network.ConnectionRequest) error {
	ret := _mock.Called(req)

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

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

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

// ConnectWiFi is a helper method to define mock.On call
//   - req network.ConnectionRequest
func (_e *MockBackend_Expecter) ConnectWiFi(req any) *MockBackend_ConnectWiFi_Call {
	return &MockBackend_ConnectWiFi_Call{Call: _e.mock.On("ConnectWiFi", req)}
}

func (_c *MockBackend_ConnectWiFi_Call) Run(run func(req network.ConnectionRequest)) *MockBackend_ConnectWiFi_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 network.ConnectionRequest
		if args[0] != nil {
			arg0 = args[0].(network.ConnectionRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockBackend_ConnectWiFi_Call) RunAndReturn(run func(req network.ConnectionRequest) error) *MockBackend_ConnectWiFi_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVPN provides a mock function for the type MockBackend
func (_mock *MockBackend) DeleteVPN(uuidOrName string) error {
	ret := _mock.Called(uuidOrName)

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

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

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

// DeleteVPN is a helper method to define mock.On call
//   - uuidOrName string
func (_e *MockBackend_Expecter) DeleteVPN(uuidOrName any) *MockBackend_DeleteVPN_Call {
	return &MockBackend_DeleteVPN_Call{Call: _e.mock.On("DeleteVPN", uuidOrName)}
}

func (_c *MockBackend_DeleteVPN_Call) Run(run func(uuidOrName string)) *MockBackend_DeleteVPN_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 *MockBackend_DeleteVPN_Call) Return(err error) *MockBackend_DeleteVPN_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockBackend_DeleteVPN_Call) RunAndReturn(run func(uuidOrName string) error) *MockBackend_DeleteVPN_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// DisconnectAllVPN is a helper method to define mock.On call
func (_e *MockBackend_Expecter) DisconnectAllVPN() *MockBackend_DisconnectAllVPN_Call {
	return &MockBackend_DisconnectAllVPN_Call{Call: _e.mock.On("DisconnectAllVPN")}
}

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

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

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

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

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

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

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

// DisconnectEthernet is a helper method to define mock.On call
func (_e *MockBackend_Expecter) DisconnectEthernet() *MockBackend_DisconnectEthernet_Call {
	return &MockBackend_DisconnectEthernet_Call{Call: _e.mock.On("DisconnectEthernet")}
}

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

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

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

// DisconnectEthernetDevice provides a mock function for the type MockBackend
func (_mock *MockBackend) DisconnectEthernetDevice(device string) error {
	ret := _mock.Called(device)

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

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

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

// DisconnectEthernetDevice is a helper method to define mock.On call
//   - device string
func (_e *MockBackend_Expecter) DisconnectEthernetDevice(device any) *MockBackend_DisconnectEthernetDevice_Call {
	return &MockBackend_DisconnectEthernetDevice_Call{Call: _e.mock.On("DisconnectEthernetDevice", device)}
}

func (_c *MockBackend_DisconnectEthernetDevice_Call) Run(run func(device string)) *MockBackend_DisconnectEthernetDevice_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 *MockBackend_DisconnectEthernetDevice_Call) Return(err error) *MockBackend_DisconnectEthernetDevice_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockBackend_DisconnectEthernetDevice_Call) RunAndReturn(run func(device string) error) *MockBackend_DisconnectEthernetDevice_Call {
	_c.Call.Return(run)
	return _c
}

// DisconnectVPN provides a mock function for the type MockBackend
func (_mock *MockBackend) DisconnectVPN(uuidOrName string) error {
	ret := _mock.Called(uuidOrName)

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

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

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

// DisconnectVPN is a helper method to define mock.On call
//   - uuidOrName string
func (_e *MockBackend_Expecter) DisconnectVPN(uuidOrName any) *MockBackend_DisconnectVPN_Call {
	return &MockBackend_DisconnectVPN_Call{Call: _e.mock.On("DisconnectVPN", uuidOrName)}
}

func (_c *MockBackend_DisconnectVPN_Call) Run(run func(uuidOrName string)) *MockBackend_DisconnectVPN_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 *MockBackend_DisconnectVPN_Call) Return(err error) *MockBackend_DisconnectVPN_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockBackend_DisconnectVPN_Call) RunAndReturn(run func(uuidOrName string) error) *MockBackend_DisconnectVPN_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// DisconnectWiFi is a helper method to define mock.On call
func (_e *MockBackend_Expecter) DisconnectWiFi() *MockBackend_DisconnectWiFi_Call {
	return &MockBackend_DisconnectWiFi_Call{Call: _e.mock.On("DisconnectWiFi")}
}

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

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

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

// DisconnectWiFiDevice provides a mock function for the type MockBackend
func (_mock *MockBackend) DisconnectWiFiDevice(device string) error {
	ret := _mock.Called(device)

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

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

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

// DisconnectWiFiDevice is a helper method to define mock.On call
//   - device string
func (_e *MockBackend_Expecter) DisconnectWiFiDevice(device any) *MockBackend_DisconnectWiFiDevice_Call {
	return &MockBackend_DisconnectWiFiDevice_Call{Call: _e.mock.On("DisconnectWiFiDevice", device)}
}

func (_c *MockBackend_DisconnectWiFiDevice_Call) Run(run func(device string)) *MockBackend_DisconnectWiFiDevice_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 *MockBackend_DisconnectWiFiDevice_Call) Return(err error) *MockBackend_DisconnectWiFiDevice_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockBackend_DisconnectWiFiDevice_Call) RunAndReturn(run func(device string) error) *MockBackend_DisconnectWiFiDevice_Call {
	_c.Call.Return(run)
	return _c
}

// ForgetWiFiNetwork provides a mock function for the type MockBackend
func (_mock *MockBackend) ForgetWiFiNetwork(ssid string) error {
	ret := _mock.Called(ssid)

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

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

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

// ForgetWiFiNetwork is a helper method to define mock.On call
//   - ssid string
func (_e *MockBackend_Expecter) ForgetWiFiNetwork(ssid any) *MockBackend_ForgetWiFiNetwork_Call {
	return &MockBackend_ForgetWiFiNetwork_Call{Call: _e.mock.On("ForgetWiFiNetwork", ssid)}
}

func (_c *MockBackend_ForgetWiFiNetwork_Call) Run(run func(ssid string)) *MockBackend_ForgetWiFiNetwork_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 *MockBackend_ForgetWiFiNetwork_Call) Return(err error) *MockBackend_ForgetWiFiNetwork_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockBackend_ForgetWiFiNetwork_Call) RunAndReturn(run func(ssid string) error) *MockBackend_ForgetWiFiNetwork_Call {
	_c.Call.Return(run)
	return _c
}

// GetCurrentState provides a mock function for the type MockBackend
func (_mock *MockBackend) GetCurrentState() (*network.BackendState, error) {
	ret := _mock.Called()

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

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

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

// GetCurrentState is a helper method to define mock.On call
func (_e *MockBackend_Expecter) GetCurrentState() *MockBackend_GetCurrentState_Call {
	return &MockBackend_GetCurrentState_Call{Call: _e.mock.On("GetCurrentState")}
}

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

func (_c *MockBackend_GetCurrentState_Call) Return(backendState *network.BackendState, err error) *MockBackend_GetCurrentState_Call {
	_c.Call.Return(backendState, err)
	return _c
}

func (_c *MockBackend_GetCurrentState_Call) RunAndReturn(run func() (*network.BackendState, error)) *MockBackend_GetCurrentState_Call {
	_c.Call.Return(run)
	return _c
}

// GetEthernetDevices provides a mock function for the type MockBackend
func (_mock *MockBackend) GetEthernetDevices() []network.EthernetDevice {
	ret := _mock.Called()

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

	var r0 []network.EthernetDevice
	if returnFunc, ok := ret.Get(0).(func() []network.EthernetDevice); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]network.EthernetDevice)
		}
	}
	return r0
}

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

// GetEthernetDevices is a helper method to define mock.On call
func (_e *MockBackend_Expecter) GetEthernetDevices() *MockBackend_GetEthernetDevices_Call {
	return &MockBackend_GetEthernetDevices_Call{Call: _e.mock.On("GetEthernetDevices")}
}

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

func (_c *MockBackend_GetEthernetDevices_Call) Return(ethernetDevices []network.EthernetDevice) *MockBackend_GetEthernetDevices_Call {
	_c.Call.Return(ethernetDevices)
	return _c
}

func (_c *MockBackend_GetEthernetDevices_Call) RunAndReturn(run func() []network.EthernetDevice) *MockBackend_GetEthernetDevices_Call {
	_c.Call.Return(run)
	return _c
}

// GetPromptBroker provides a mock function for the type MockBackend
func (_mock *MockBackend) GetPromptBroker() network.PromptBroker {
	ret := _mock.Called()

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

	var r0 network.PromptBroker
	if returnFunc, ok := ret.Get(0).(func() network.PromptBroker); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(network.PromptBroker)
		}
	}
	return r0
}

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

// GetPromptBroker is a helper method to define mock.On call
func (_e *MockBackend_Expecter) GetPromptBroker() *MockBackend_GetPromptBroker_Call {
	return &MockBackend_GetPromptBroker_Call{Call: _e.mock.On("GetPromptBroker")}
}

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

func (_c *MockBackend_GetPromptBroker_Call) Return(promptBroker network.PromptBroker) *MockBackend_GetPromptBroker_Call {
	_c.Call.Return(promptBroker)
	return _c
}

func (_c *MockBackend_GetPromptBroker_Call) RunAndReturn(run func() network.PromptBroker) *MockBackend_GetPromptBroker_Call {
	_c.Call.Return(run)
	return _c
}

// GetVPNConfig provides a mock function for the type MockBackend
func (_mock *MockBackend) GetVPNConfig(uuidOrName string) (*network.VPNConfig, error) {
	ret := _mock.Called(uuidOrName)

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

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

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

// GetVPNConfig is a helper method to define mock.On call
//   - uuidOrName string
func (_e *MockBackend_Expecter) GetVPNConfig(uuidOrName any) *MockBackend_GetVPNConfig_Call {
	return &MockBackend_GetVPNConfig_Call{Call: _e.mock.On("GetVPNConfig", uuidOrName)}
}

func (_c *MockBackend_GetVPNConfig_Call) Run(run func(uuidOrName string)) *MockBackend_GetVPNConfig_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 *MockBackend_GetVPNConfig_Call) Return(vPNConfig *network.VPNConfig, err error) *MockBackend_GetVPNConfig_Call {
	_c.Call.Return(vPNConfig, err)
	return _c
}

func (_c *MockBackend_GetVPNConfig_Call) RunAndReturn(run func(uuidOrName string) (*network.VPNConfig, error)) *MockBackend_GetVPNConfig_Call {
	_c.Call.Return(run)
	return _c
}

// GetWiFiDevices provides a mock function for the type MockBackend
func (_mock *MockBackend) GetWiFiDevices() []network.WiFiDevice {
	ret := _mock.Called()

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

	var r0 []network.WiFiDevice
	if returnFunc, ok := ret.Get(0).(func() []network.WiFiDevice); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]network.WiFiDevice)
		}
	}
	return r0
}

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

// GetWiFiDevices is a helper method to define mock.On call
func (_e *MockBackend_Expecter) GetWiFiDevices() *MockBackend_GetWiFiDevices_Call {
	return &MockBackend_GetWiFiDevices_Call{Call: _e.mock.On("GetWiFiDevices")}
}

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

func (_c *MockBackend_GetWiFiDevices_Call) Return(wiFiDevices []network.WiFiDevice) *MockBackend_GetWiFiDevices_Call {
	_c.Call.Return(wiFiDevices)
	return _c
}

func (_c *MockBackend_GetWiFiDevices_Call) RunAndReturn(run func() []network.WiFiDevice) *MockBackend_GetWiFiDevices_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	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
}

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

// GetWiFiEnabled is a helper method to define mock.On call
func (_e *MockBackend_Expecter) GetWiFiEnabled() *MockBackend_GetWiFiEnabled_Call {
	return &MockBackend_GetWiFiEnabled_Call{Call: _e.mock.On("GetWiFiEnabled")}
}

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

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

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

// GetWiFiNetworkDetails provides a mock function for the type MockBackend
func (_mock *MockBackend) GetWiFiNetworkDetails(ssid string) (*network.NetworkInfoResponse, error) {
	ret := _mock.Called(ssid)

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

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

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

// GetWiFiNetworkDetails is a helper method to define mock.On call
//   - ssid string
func (_e *MockBackend_Expecter) GetWiFiNetworkDetails(ssid any) *MockBackend_GetWiFiNetworkDetails_Call {
	return &MockBackend_GetWiFiNetworkDetails_Call{Call: _e.mock.On("GetWiFiNetworkDetails", ssid)}
}

func (_c *MockBackend_GetWiFiNetworkDetails_Call) Run(run func(ssid string)) *MockBackend_GetWiFiNetworkDetails_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 *MockBackend_GetWiFiNetworkDetails_Call) Return(networkInfoResponse *network.NetworkInfoResponse, err error) *MockBackend_GetWiFiNetworkDetails_Call {
	_c.Call.Return(networkInfoResponse, err)
	return _c
}

func (_c *MockBackend_GetWiFiNetworkDetails_Call) RunAndReturn(run func(ssid string) (*network.NetworkInfoResponse, error)) *MockBackend_GetWiFiNetworkDetails_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// GetWiFiQRCodeContent is a helper method to define mock.On call
//   - ssid string
func (_e *MockBackend_Expecter) GetWiFiQRCodeContent(ssid any) *MockBackend_GetWiFiQRCodeContent_Call {
	return &MockBackend_GetWiFiQRCodeContent_Call{Call: _e.mock.On("GetWiFiQRCodeContent", ssid)}
}

func (_c *MockBackend_GetWiFiQRCodeContent_Call) Run(run func(ssid string)) *MockBackend_GetWiFiQRCodeContent_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 *MockBackend_GetWiFiQRCodeContent_Call) Return(s string, err error) *MockBackend_GetWiFiQRCodeContent_Call {
	_c.Call.Return(s, err)
	return _c
}

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

// GetWiredConnections provides a mock function for the type MockBackend
func (_mock *MockBackend) GetWiredConnections() ([]network.WiredConnection, error) {
	ret := _mock.Called()

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

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

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

// GetWiredConnections is a helper method to define mock.On call
func (_e *MockBackend_Expecter) GetWiredConnections() *MockBackend_GetWiredConnections_Call {
	return &MockBackend_GetWiredConnections_Call{Call: _e.mock.On("GetWiredConnections")}
}

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

func (_c *MockBackend_GetWiredConnections_Call) Return(wiredConnections []network.WiredConnection, err error) *MockBackend_GetWiredConnections_Call {
	_c.Call.Return(wiredConnections, err)
	return _c
}

func (_c *MockBackend_GetWiredConnections_Call) RunAndReturn(run func() ([]network.WiredConnection, error)) *MockBackend_GetWiredConnections_Call {
	_c.Call.Return(run)
	return _c
}

// GetWiredNetworkDetails provides a mock function for the type MockBackend
func (_mock *MockBackend) GetWiredNetworkDetails(uuid string) (*network.WiredNetworkInfoResponse, error) {
	ret := _mock.Called(uuid)

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

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

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

// GetWiredNetworkDetails is a helper method to define mock.On call
//   - uuid string
func (_e *MockBackend_Expecter) GetWiredNetworkDetails(uuid any) *MockBackend_GetWiredNetworkDetails_Call {
	return &MockBackend_GetWiredNetworkDetails_Call{Call: _e.mock.On("GetWiredNetworkDetails", uuid)}
}

func (_c *MockBackend_GetWiredNetworkDetails_Call) Run(run func(uuid string)) *MockBackend_GetWiredNetworkDetails_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 *MockBackend_GetWiredNetworkDetails_Call) Return(wiredNetworkInfoResponse *network.WiredNetworkInfoResponse, err error) *MockBackend_GetWiredNetworkDetails_Call {
	_c.Call.Return(wiredNetworkInfoResponse, err)
	return _c
}

func (_c *MockBackend_GetWiredNetworkDetails_Call) RunAndReturn(run func(uuid string) (*network.WiredNetworkInfoResponse, error)) *MockBackend_GetWiredNetworkDetails_Call {
	_c.Call.Return(run)
	return _c
}

// ImportVPN provides a mock function for the type MockBackend
func (_mock *MockBackend) ImportVPN(filePath string, name string) (*network.VPNImportResult, error) {
	ret := _mock.Called(filePath, name)

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

	var r0 *network.VPNImportResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string, string) (*network.VPNImportResult, error)); ok {
		return returnFunc(filePath, name)
	}
	if returnFunc, ok := ret.Get(0).(func(string, string) *network.VPNImportResult); ok {
		r0 = returnFunc(filePath, name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*network.VPNImportResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string, string) error); ok {
		r1 = returnFunc(filePath, name)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ImportVPN is a helper method to define mock.On call
//   - filePath string
//   - name string
func (_e *MockBackend_Expecter) ImportVPN(filePath any, name any) *MockBackend_ImportVPN_Call {
	return &MockBackend_ImportVPN_Call{Call: _e.mock.On("ImportVPN", filePath, name)}
}

func (_c *MockBackend_ImportVPN_Call) Run(run func(filePath string, name string)) *MockBackend_ImportVPN_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockBackend_ImportVPN_Call) Return(vPNImportResult *network.VPNImportResult, err error) *MockBackend_ImportVPN_Call {
	_c.Call.Return(vPNImportResult, err)
	return _c
}

func (_c *MockBackend_ImportVPN_Call) RunAndReturn(run func(filePath string, name string) (*network.VPNImportResult, error)) *MockBackend_ImportVPN_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// Initialize is a helper method to define mock.On call
func (_e *MockBackend_Expecter) Initialize() *MockBackend_Initialize_Call {
	return &MockBackend_Initialize_Call{Call: _e.mock.On("Initialize")}
}

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

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

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

// ListActiveVPN provides a mock function for the type MockBackend
func (_mock *MockBackend) ListActiveVPN() ([]network.VPNActive, error) {
	ret := _mock.Called()

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

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

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

// ListActiveVPN is a helper method to define mock.On call
func (_e *MockBackend_Expecter) ListActiveVPN() *MockBackend_ListActiveVPN_Call {
	return &MockBackend_ListActiveVPN_Call{Call: _e.mock.On("ListActiveVPN")}
}

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

func (_c *MockBackend_ListActiveVPN_Call) Return(vPNActives []network.VPNActive, err error) *MockBackend_ListActiveVPN_Call {
	_c.Call.Return(vPNActives, err)
	return _c
}

func (_c *MockBackend_ListActiveVPN_Call) RunAndReturn(run func() ([]network.VPNActive, error)) *MockBackend_ListActiveVPN_Call {
	_c.Call.Return(run)
	return _c
}

// ListVPNPlugins provides a mock function for the type MockBackend
func (_mock *MockBackend) ListVPNPlugins() ([]network.VPNPlugin, error) {
	ret := _mock.Called()

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

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

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

// ListVPNPlugins is a helper method to define mock.On call
func (_e *MockBackend_Expecter) ListVPNPlugins() *MockBackend_ListVPNPlugins_Call {
	return &MockBackend_ListVPNPlugins_Call{Call: _e.mock.On("ListVPNPlugins")}
}

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

func (_c *MockBackend_ListVPNPlugins_Call) Return(vPNPlugins []network.VPNPlugin, err error) *MockBackend_ListVPNPlugins_Call {
	_c.Call.Return(vPNPlugins, err)
	return _c
}

func (_c *MockBackend_ListVPNPlugins_Call) RunAndReturn(run func() ([]network.VPNPlugin, error)) *MockBackend_ListVPNPlugins_Call {
	_c.Call.Return(run)
	return _c
}

// ListVPNProfiles provides a mock function for the type MockBackend
func (_mock *MockBackend) ListVPNProfiles() ([]network.VPNProfile, error) {
	ret := _mock.Called()

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

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

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

// ListVPNProfiles is a helper method to define mock.On call
func (_e *MockBackend_Expecter) ListVPNProfiles() *MockBackend_ListVPNProfiles_Call {
	return &MockBackend_ListVPNProfiles_Call{Call: _e.mock.On("ListVPNProfiles")}
}

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

func (_c *MockBackend_ListVPNProfiles_Call) Return(vPNProfiles []network.VPNProfile, err error) *MockBackend_ListVPNProfiles_Call {
	_c.Call.Return(vPNProfiles, err)
	return _c
}

func (_c *MockBackend_ListVPNProfiles_Call) RunAndReturn(run func() ([]network.VPNProfile, error)) *MockBackend_ListVPNProfiles_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// ScanWiFi is a helper method to define mock.On call
func (_e *MockBackend_Expecter) ScanWiFi() *MockBackend_ScanWiFi_Call {
	return &MockBackend_ScanWiFi_Call{Call: _e.mock.On("ScanWiFi")}
}

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

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

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

// ScanWiFiDevice provides a mock function for the type MockBackend
func (_mock *MockBackend) ScanWiFiDevice(device string) error {
	ret := _mock.Called(device)

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

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

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

// ScanWiFiDevice is a helper method to define mock.On call
//   - device string
func (_e *MockBackend_Expecter) ScanWiFiDevice(device any) *MockBackend_ScanWiFiDevice_Call {
	return &MockBackend_ScanWiFiDevice_Call{Call: _e.mock.On("ScanWiFiDevice", device)}
}

func (_c *MockBackend_ScanWiFiDevice_Call) Run(run func(device string)) *MockBackend_ScanWiFiDevice_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 *MockBackend_ScanWiFiDevice_Call) Return(err error) *MockBackend_ScanWiFiDevice_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockBackend_ScanWiFiDevice_Call) RunAndReturn(run func(device string) error) *MockBackend_ScanWiFiDevice_Call {
	_c.Call.Return(run)
	return _c
}

// SetPromptBroker provides a mock function for the type MockBackend
func (_mock *MockBackend) SetPromptBroker(broker network.PromptBroker) error {
	ret := _mock.Called(broker)

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

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

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

// SetPromptBroker is a helper method to define mock.On call
//   - broker network.PromptBroker
func (_e *MockBackend_Expecter) SetPromptBroker(broker any) *MockBackend_SetPromptBroker_Call {
	return &MockBackend_SetPromptBroker_Call{Call: _e.mock.On("SetPromptBroker", broker)}
}

func (_c *MockBackend_SetPromptBroker_Call) Run(run func(broker network.PromptBroker)) *MockBackend_SetPromptBroker_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 network.PromptBroker
		if args[0] != nil {
			arg0 = args[0].(network.PromptBroker)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockBackend_SetPromptBroker_Call) RunAndReturn(run func(broker network.PromptBroker) error) *MockBackend_SetPromptBroker_Call {
	_c.Call.Return(run)
	return _c
}

// SetVPNCredentials provides a mock function for the type MockBackend
func (_mock *MockBackend) SetVPNCredentials(uuid string, username string, password string, save bool) error {
	ret := _mock.Called(uuid, username, password, save)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, string, string, bool) error); ok {
		r0 = returnFunc(uuid, username, password, save)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetVPNCredentials is a helper method to define mock.On call
//   - uuid string
//   - username string
//   - password string
//   - save bool
func (_e *MockBackend_Expecter) SetVPNCredentials(uuid any, username any, password any, save any) *MockBackend_SetVPNCredentials_Call {
	return &MockBackend_SetVPNCredentials_Call{Call: _e.mock.On("SetVPNCredentials", uuid, username, password, save)}
}

func (_c *MockBackend_SetVPNCredentials_Call) Run(run func(uuid string, username string, password string, save bool)) *MockBackend_SetVPNCredentials_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 bool
		if args[3] != nil {
			arg3 = args[3].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *MockBackend_SetVPNCredentials_Call) RunAndReturn(run func(uuid string, username string, password string, save bool) error) *MockBackend_SetVPNCredentials_Call {
	_c.Call.Return(run)
	return _c
}

// SetWiFiAutoconnect provides a mock function for the type MockBackend
func (_mock *MockBackend) SetWiFiAutoconnect(ssid string, autoconnect bool) error {
	ret := _mock.Called(ssid, autoconnect)

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

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

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

// SetWiFiAutoconnect is a helper method to define mock.On call
//   - ssid string
//   - autoconnect bool
func (_e *MockBackend_Expecter) SetWiFiAutoconnect(ssid any, autoconnect any) *MockBackend_SetWiFiAutoconnect_Call {
	return &MockBackend_SetWiFiAutoconnect_Call{Call: _e.mock.On("SetWiFiAutoconnect", ssid, autoconnect)}
}

func (_c *MockBackend_SetWiFiAutoconnect_Call) Run(run func(ssid string, autoconnect bool)) *MockBackend_SetWiFiAutoconnect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockBackend_SetWiFiAutoconnect_Call) RunAndReturn(run func(ssid string, autoconnect bool) error) *MockBackend_SetWiFiAutoconnect_Call {
	_c.Call.Return(run)
	return _c
}

// SetWiFiEnabled provides a mock function for the type MockBackend
func (_mock *MockBackend) SetWiFiEnabled(enabled bool) error {
	ret := _mock.Called(enabled)

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

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

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

// SetWiFiEnabled is a helper method to define mock.On call
//   - enabled bool
func (_e *MockBackend_Expecter) SetWiFiEnabled(enabled any) *MockBackend_SetWiFiEnabled_Call {
	return &MockBackend_SetWiFiEnabled_Call{Call: _e.mock.On("SetWiFiEnabled", enabled)}
}

func (_c *MockBackend_SetWiFiEnabled_Call) Run(run func(enabled bool)) *MockBackend_SetWiFiEnabled_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 *MockBackend_SetWiFiEnabled_Call) Return(err error) *MockBackend_SetWiFiEnabled_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockBackend_SetWiFiEnabled_Call) RunAndReturn(run func(enabled bool) error) *MockBackend_SetWiFiEnabled_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// StartMonitoring is a helper method to define mock.On call
//   - onStateChange func()
func (_e *MockBackend_Expecter) StartMonitoring(onStateChange any) *MockBackend_StartMonitoring_Call {
	return &MockBackend_StartMonitoring_Call{Call: _e.mock.On("StartMonitoring", onStateChange)}
}

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

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

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

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

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

// StopMonitoring is a helper method to define mock.On call
func (_e *MockBackend_Expecter) StopMonitoring() *MockBackend_StopMonitoring_Call {
	return &MockBackend_StopMonitoring_Call{Call: _e.mock.On("StopMonitoring")}
}

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

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

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

// SubmitCredentials provides a mock function for the type MockBackend
func (_mock *MockBackend) SubmitCredentials(token string, secrets map[string]string, save bool) error {
	ret := _mock.Called(token, secrets, save)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, map[string]string, bool) error); ok {
		r0 = returnFunc(token, secrets, save)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SubmitCredentials is a helper method to define mock.On call
//   - token string
//   - secrets map[string]string
//   - save bool
func (_e *MockBackend_Expecter) SubmitCredentials(token any, secrets any, save any) *MockBackend_SubmitCredentials_Call {
	return &MockBackend_SubmitCredentials_Call{Call: _e.mock.On("SubmitCredentials", token, secrets, save)}
}

func (_c *MockBackend_SubmitCredentials_Call) Run(run func(token string, secrets map[string]string, save bool)) *MockBackend_SubmitCredentials_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 map[string]string
		if args[1] != nil {
			arg1 = args[1].(map[string]string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockBackend_SubmitCredentials_Call) RunAndReturn(run func(token string, secrets map[string]string, save bool) error) *MockBackend_SubmitCredentials_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateVPNConfig provides a mock function for the type MockBackend
func (_mock *MockBackend) UpdateVPNConfig(uuid string, updates map[string]any) error {
	ret := _mock.Called(uuid, updates)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, map[string]any) error); ok {
		r0 = returnFunc(uuid, updates)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UpdateVPNConfig is a helper method to define mock.On call
//   - uuid string
//   - updates map[string]any
func (_e *MockBackend_Expecter) UpdateVPNConfig(uuid any, updates any) *MockBackend_UpdateVPNConfig_Call {
	return &MockBackend_UpdateVPNConfig_Call{Call: _e.mock.On("UpdateVPNConfig", uuid, updates)}
}

func (_c *MockBackend_UpdateVPNConfig_Call) Run(run func(uuid string, updates map[string]any)) *MockBackend_UpdateVPNConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 map[string]any
		if args[1] != nil {
			arg1 = args[1].(map[string]any)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockBackend_UpdateVPNConfig_Call) RunAndReturn(run func(uuid string, updates map[string]any) error) *MockBackend_UpdateVPNConfig_Call {
	_c.Call.Return(run)
	return _c
}
