// Code generated by mockery v2.53.5. DO NOT EDIT.

package mocks_network

import (
	network "github.com/AvengeMedia/danklinux/internal/server/network"
	mock "github.com/stretchr/testify/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 with given fields: uuid
func (_m *MockBackend) ActivateWiredConnection(uuid string) error {
	ret := _m.Called(uuid)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string) error); ok {
		r0 = rf(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 interface{}) *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) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockBackend_ActivateWiredConnection_Call) Return(_a0 error) *MockBackend_ActivateWiredConnection_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// CancelCredentials provides a mock function with given fields: token
func (_m *MockBackend) CancelCredentials(token string) error {
	ret := _m.Called(token)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string) error); ok {
		r0 = rf(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 interface{}) *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) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockBackend_CancelCredentials_Call) Return(_a0 error) *MockBackend_CancelCredentials_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ClearVPNCredentials provides a mock function with given fields: uuidOrName
func (_m *MockBackend) ClearVPNCredentials(uuidOrName string) error {
	ret := _m.Called(uuidOrName)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string) error); ok {
		r0 = rf(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 interface{}) *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) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockBackend_ClearVPNCredentials_Call) Return(_a0 error) *MockBackend_ClearVPNCredentials_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// Close provides a mock function with no fields
func (_m *MockBackend) Close() {
	_m.Called()
}

// 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 with no fields
func (_m *MockBackend) ConnectEthernet() error {
	ret := _m.Called()

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

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} 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(_a0 error) *MockBackend_ConnectEthernet_Call {
	_c.Call.Return(_a0)
	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 with given fields: uuidOrName, singleActive
func (_m *MockBackend) ConnectVPN(uuidOrName string, singleActive bool) error {
	ret := _m.Called(uuidOrName, singleActive)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string, bool) error); ok {
		r0 = rf(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 interface{}, singleActive interface{}) *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) {
		run(args[0].(string), args[1].(bool))
	})
	return _c
}

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

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

// ConnectWiFi provides a mock function with given fields: req
func (_m *MockBackend) ConnectWiFi(req network.ConnectionRequest) error {
	ret := _m.Called(req)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(network.ConnectionRequest) error); ok {
		r0 = rf(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 interface{}) *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) {
		run(args[0].(network.ConnectionRequest))
	})
	return _c
}

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

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

// DisconnectAllVPN provides a mock function with no fields
func (_m *MockBackend) DisconnectAllVPN() error {
	ret := _m.Called()

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

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} 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(_a0 error) *MockBackend_DisconnectAllVPN_Call {
	_c.Call.Return(_a0)
	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 with no fields
func (_m *MockBackend) DisconnectEthernet() error {
	ret := _m.Called()

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

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} 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(_a0 error) *MockBackend_DisconnectEthernet_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// DisconnectVPN provides a mock function with given fields: uuidOrName
func (_m *MockBackend) DisconnectVPN(uuidOrName string) error {
	ret := _m.Called(uuidOrName)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string) error); ok {
		r0 = rf(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 interface{}) *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) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockBackend_DisconnectVPN_Call) Return(_a0 error) *MockBackend_DisconnectVPN_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// DisconnectWiFi provides a mock function with no fields
func (_m *MockBackend) DisconnectWiFi() error {
	ret := _m.Called()

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

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} 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(_a0 error) *MockBackend_DisconnectWiFi_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ForgetWiFiNetwork provides a mock function with given fields: ssid
func (_m *MockBackend) ForgetWiFiNetwork(ssid string) error {
	ret := _m.Called(ssid)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string) error); ok {
		r0 = rf(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 interface{}) *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) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockBackend_ForgetWiFiNetwork_Call) Return(_a0 error) *MockBackend_ForgetWiFiNetwork_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetCurrentState provides a mock function with no fields
func (_m *MockBackend) GetCurrentState() (*network.BackendState, error) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} 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(_a0 *network.BackendState, _a1 error) *MockBackend_GetCurrentState_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetPromptBroker provides a mock function with no fields
func (_m *MockBackend) GetPromptBroker() network.PromptBroker {
	ret := _m.Called()

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

	var r0 network.PromptBroker
	if rf, ok := ret.Get(0).(func() network.PromptBroker); ok {
		r0 = rf()
	} 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(_a0 network.PromptBroker) *MockBackend_GetPromptBroker_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetWiFiEnabled provides a mock function with no fields
func (_m *MockBackend) GetWiFiEnabled() (bool, error) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} 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(_a0 bool, _a1 error) *MockBackend_GetWiFiEnabled_Call {
	_c.Call.Return(_a0, _a1)
	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 with given fields: ssid
func (_m *MockBackend) GetWiFiNetworkDetails(ssid string) (*network.NetworkInfoResponse, error) {
	ret := _m.Called(ssid)

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

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

	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(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 interface{}) *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) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockBackend_GetWiFiNetworkDetails_Call) Return(_a0 *network.NetworkInfoResponse, _a1 error) *MockBackend_GetWiFiNetworkDetails_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetWiredConnections provides a mock function with no fields
func (_m *MockBackend) GetWiredConnections() ([]network.WiredConnection, error) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} 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(_a0 []network.WiredConnection, _a1 error) *MockBackend_GetWiredConnections_Call {
	_c.Call.Return(_a0, _a1)
	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 with given fields: uuid
func (_m *MockBackend) GetWiredNetworkDetails(uuid string) (*network.WiredNetworkInfoResponse, error) {
	ret := _m.Called(uuid)

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

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

	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(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 interface{}) *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) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockBackend_GetWiredNetworkDetails_Call) Return(_a0 *network.WiredNetworkInfoResponse, _a1 error) *MockBackend_GetWiredNetworkDetails_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// Initialize provides a mock function with no fields
func (_m *MockBackend) Initialize() error {
	ret := _m.Called()

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

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} 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(_a0 error) *MockBackend_Initialize_Call {
	_c.Call.Return(_a0)
	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 with no fields
func (_m *MockBackend) ListActiveVPN() ([]network.VPNActive, error) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} 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(_a0 []network.VPNActive, _a1 error) *MockBackend_ListActiveVPN_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// ListVPNProfiles provides a mock function with no fields
func (_m *MockBackend) ListVPNProfiles() ([]network.VPNProfile, error) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} 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(_a0 []network.VPNProfile, _a1 error) *MockBackend_ListVPNProfiles_Call {
	_c.Call.Return(_a0, _a1)
	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 with no fields
func (_m *MockBackend) ScanWiFi() error {
	ret := _m.Called()

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

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} 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(_a0 error) *MockBackend_ScanWiFi_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// SetPromptBroker provides a mock function with given fields: broker
func (_m *MockBackend) SetPromptBroker(broker network.PromptBroker) error {
	ret := _m.Called(broker)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(network.PromptBroker) error); ok {
		r0 = rf(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 interface{}) *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) {
		run(args[0].(network.PromptBroker))
	})
	return _c
}

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

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

// SetWiFiAutoconnect provides a mock function with given fields: ssid, autoconnect
func (_m *MockBackend) SetWiFiAutoconnect(ssid string, autoconnect bool) error {
	ret := _m.Called(ssid, autoconnect)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string, bool) error); ok {
		r0 = rf(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 interface{}, autoconnect interface{}) *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) {
		run(args[0].(string), args[1].(bool))
	})
	return _c
}

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

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

// SetWiFiEnabled provides a mock function with given fields: enabled
func (_m *MockBackend) SetWiFiEnabled(enabled bool) error {
	ret := _m.Called(enabled)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(bool) error); ok {
		r0 = rf(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 interface{}) *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) {
		run(args[0].(bool))
	})
	return _c
}

func (_c *MockBackend_SetWiFiEnabled_Call) Return(_a0 error) *MockBackend_SetWiFiEnabled_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func()) error); ok {
		r0 = rf(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 interface{}) *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) {
		run(args[0].(func()))
	})
	return _c
}

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

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

// StopMonitoring provides a mock function with no fields
func (_m *MockBackend) StopMonitoring() {
	_m.Called()
}

// 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 with given fields: token, secrets, save
func (_m *MockBackend) SubmitCredentials(token string, secrets map[string]string, save bool) error {
	ret := _m.Called(token, secrets, save)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string, map[string]string, bool) error); ok {
		r0 = rf(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 interface{}, secrets interface{}, save interface{}) *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) {
		run(args[0].(string), args[1].(map[string]string), args[2].(bool))
	})
	return _c
}

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

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

// 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
}
