Replaced file structures for themes in the correct format

21 files changed, 16482 insertions, 0 deletions

diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/brightness/mock_DBusConn.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/brightness/mock_DBusConn.go
new file mode 100644
index 0000000..ce9472d
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/brightness/mock_DBusConn.go
@@ -0,0 +1,130 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package mocks_brightness
+
+import (
+	dbus "github.com/godbus/dbus/v5"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockDBusConn is an autogenerated mock type for the DBusConn type
+type MockDBusConn struct {
+	mock.Mock
+}
+
+type MockDBusConn_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockDBusConn) EXPECT() *MockDBusConn_Expecter {
+	return &MockDBusConn_Expecter{mock: &_m.Mock}
+}
+
+// Close provides a mock function with no fields
+func (_m *MockDBusConn) Close() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Close")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockDBusConn_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type MockDBusConn_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+func (_e *MockDBusConn_Expecter) Close() *MockDBusConn_Close_Call {
+	return &MockDBusConn_Close_Call{Call: _e.mock.On("Close")}
+}
+
+func (_c *MockDBusConn_Close_Call) Run(run func()) *MockDBusConn_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDBusConn_Close_Call) Return(_a0 error) *MockDBusConn_Close_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockDBusConn_Close_Call) RunAndReturn(run func() error) *MockDBusConn_Close_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Object provides a mock function with given fields: dest, path
+func (_m *MockDBusConn) Object(dest string, path dbus.ObjectPath) dbus.BusObject {
+	ret := _m.Called(dest, path)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Object")
+	}
+
+	var r0 dbus.BusObject
+	if rf, ok := ret.Get(0).(func(string, dbus.ObjectPath) dbus.BusObject); ok {
+		r0 = rf(dest, path)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(dbus.BusObject)
+		}
+	}
+
+	return r0
+}
+
+// MockDBusConn_Object_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Object'
+type MockDBusConn_Object_Call struct {
+	*mock.Call
+}
+
+// Object is a helper method to define mock.On call
+//   - dest string
+//   - path dbus.ObjectPath
+func (_e *MockDBusConn_Expecter) Object(dest any, path any) *MockDBusConn_Object_Call {
+	return &MockDBusConn_Object_Call{Call: _e.mock.On("Object", dest, path)}
+}
+
+func (_c *MockDBusConn_Object_Call) Run(run func(dest string, path dbus.ObjectPath)) *MockDBusConn_Object_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(dbus.ObjectPath))
+	})
+	return _c
+}
+
+func (_c *MockDBusConn_Object_Call) Return(_a0 dbus.BusObject) *MockDBusConn_Object_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockDBusConn_Object_Call) RunAndReturn(run func(string, dbus.ObjectPath) dbus.BusObject) *MockDBusConn_Object_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockDBusConn creates a new instance of MockDBusConn. 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 NewMockDBusConn(t interface {
+	mock.TestingT
+	Cleanup(func())
+},
+) *MockDBusConn {
+	mock := &MockDBusConn{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/cups/mock_CUPSClientInterface.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/cups/mock_CUPSClientInterface.go
new file mode 100644
index 0000000..3c98074
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/cups/mock_CUPSClientInterface.go
@@ -0,0 +1,1246 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package mocks_cups
+
+import (
+	io "io"
+
+	ipp "github.com/AvengeMedia/DankMaterialShell/core/pkg/ipp"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockCUPSClientInterface is an autogenerated mock type for the CUPSClientInterface type
+type MockCUPSClientInterface struct {
+	mock.Mock
+}
+
+type MockCUPSClientInterface_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockCUPSClientInterface) EXPECT() *MockCUPSClientInterface_Expecter {
+	return &MockCUPSClientInterface_Expecter{mock: &_m.Mock}
+}
+
+// AcceptJobs provides a mock function with given fields: printer
+func (_m *MockCUPSClientInterface) AcceptJobs(printer string) error {
+	ret := _m.Called(printer)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AcceptJobs")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(printer)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_AcceptJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcceptJobs'
+type MockCUPSClientInterface_AcceptJobs_Call struct {
+	*mock.Call
+}
+
+// AcceptJobs is a helper method to define mock.On call
+//   - printer string
+func (_e *MockCUPSClientInterface_Expecter) AcceptJobs(printer interface{}) *MockCUPSClientInterface_AcceptJobs_Call {
+	return &MockCUPSClientInterface_AcceptJobs_Call{Call: _e.mock.On("AcceptJobs", printer)}
+}
+
+func (_c *MockCUPSClientInterface_AcceptJobs_Call) Run(run func(printer string)) *MockCUPSClientInterface_AcceptJobs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_AcceptJobs_Call) Return(_a0 error) *MockCUPSClientInterface_AcceptJobs_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_AcceptJobs_Call) RunAndReturn(run func(string) error) *MockCUPSClientInterface_AcceptJobs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// AddPrinterToClass provides a mock function with given fields: class, printer
+func (_m *MockCUPSClientInterface) AddPrinterToClass(class string, printer string) error {
+	ret := _m.Called(class, printer)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AddPrinterToClass")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(class, printer)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_AddPrinterToClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddPrinterToClass'
+type MockCUPSClientInterface_AddPrinterToClass_Call struct {
+	*mock.Call
+}
+
+// AddPrinterToClass is a helper method to define mock.On call
+//   - class string
+//   - printer string
+func (_e *MockCUPSClientInterface_Expecter) AddPrinterToClass(class interface{}, printer interface{}) *MockCUPSClientInterface_AddPrinterToClass_Call {
+	return &MockCUPSClientInterface_AddPrinterToClass_Call{Call: _e.mock.On("AddPrinterToClass", class, printer)}
+}
+
+func (_c *MockCUPSClientInterface_AddPrinterToClass_Call) Run(run func(class string, printer string)) *MockCUPSClientInterface_AddPrinterToClass_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_AddPrinterToClass_Call) Return(_a0 error) *MockCUPSClientInterface_AddPrinterToClass_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_AddPrinterToClass_Call) RunAndReturn(run func(string, string) error) *MockCUPSClientInterface_AddPrinterToClass_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CancelAllJob provides a mock function with given fields: printer, purge
+func (_m *MockCUPSClientInterface) CancelAllJob(printer string, purge bool) error {
+	ret := _m.Called(printer, purge)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CancelAllJob")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, bool) error); ok {
+		r0 = rf(printer, purge)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_CancelAllJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelAllJob'
+type MockCUPSClientInterface_CancelAllJob_Call struct {
+	*mock.Call
+}
+
+// CancelAllJob is a helper method to define mock.On call
+//   - printer string
+//   - purge bool
+func (_e *MockCUPSClientInterface_Expecter) CancelAllJob(printer interface{}, purge interface{}) *MockCUPSClientInterface_CancelAllJob_Call {
+	return &MockCUPSClientInterface_CancelAllJob_Call{Call: _e.mock.On("CancelAllJob", printer, purge)}
+}
+
+func (_c *MockCUPSClientInterface_CancelAllJob_Call) Run(run func(printer string, purge bool)) *MockCUPSClientInterface_CancelAllJob_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(bool))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_CancelAllJob_Call) Return(_a0 error) *MockCUPSClientInterface_CancelAllJob_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_CancelAllJob_Call) RunAndReturn(run func(string, bool) error) *MockCUPSClientInterface_CancelAllJob_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CancelJob provides a mock function with given fields: jobID, purge
+func (_m *MockCUPSClientInterface) CancelJob(jobID int, purge bool) error {
+	ret := _m.Called(jobID, purge)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CancelJob")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(int, bool) error); ok {
+		r0 = rf(jobID, purge)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_CancelJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelJob'
+type MockCUPSClientInterface_CancelJob_Call struct {
+	*mock.Call
+}
+
+// CancelJob is a helper method to define mock.On call
+//   - jobID int
+//   - purge bool
+func (_e *MockCUPSClientInterface_Expecter) CancelJob(jobID interface{}, purge interface{}) *MockCUPSClientInterface_CancelJob_Call {
+	return &MockCUPSClientInterface_CancelJob_Call{Call: _e.mock.On("CancelJob", jobID, purge)}
+}
+
+func (_c *MockCUPSClientInterface_CancelJob_Call) Run(run func(jobID int, purge bool)) *MockCUPSClientInterface_CancelJob_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(int), args[1].(bool))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_CancelJob_Call) Return(_a0 error) *MockCUPSClientInterface_CancelJob_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_CancelJob_Call) RunAndReturn(run func(int, bool) error) *MockCUPSClientInterface_CancelJob_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CreatePrinter provides a mock function with given fields: name, deviceURI, ppd, shared, errorPolicy, information, location
+func (_m *MockCUPSClientInterface) CreatePrinter(name string, deviceURI string, ppd string, shared bool, errorPolicy string, information string, location string) error {
+	ret := _m.Called(name, deviceURI, ppd, shared, errorPolicy, information, location)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CreatePrinter")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string, string, bool, string, string, string) error); ok {
+		r0 = rf(name, deviceURI, ppd, shared, errorPolicy, information, location)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_CreatePrinter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePrinter'
+type MockCUPSClientInterface_CreatePrinter_Call struct {
+	*mock.Call
+}
+
+// CreatePrinter is a helper method to define mock.On call
+//   - name string
+//   - deviceURI string
+//   - ppd string
+//   - shared bool
+//   - errorPolicy string
+//   - information string
+//   - location string
+func (_e *MockCUPSClientInterface_Expecter) CreatePrinter(name interface{}, deviceURI interface{}, ppd interface{}, shared interface{}, errorPolicy interface{}, information interface{}, location interface{}) *MockCUPSClientInterface_CreatePrinter_Call {
+	return &MockCUPSClientInterface_CreatePrinter_Call{Call: _e.mock.On("CreatePrinter", name, deviceURI, ppd, shared, errorPolicy, information, location)}
+}
+
+func (_c *MockCUPSClientInterface_CreatePrinter_Call) Run(run func(name string, deviceURI string, ppd string, shared bool, errorPolicy string, information string, location string)) *MockCUPSClientInterface_CreatePrinter_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string), args[2].(string), args[3].(bool), args[4].(string), args[5].(string), args[6].(string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_CreatePrinter_Call) Return(_a0 error) *MockCUPSClientInterface_CreatePrinter_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_CreatePrinter_Call) RunAndReturn(run func(string, string, string, bool, string, string, string) error) *MockCUPSClientInterface_CreatePrinter_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeleteClass provides a mock function with given fields: class
+func (_m *MockCUPSClientInterface) DeleteClass(class string) error {
+	ret := _m.Called(class)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteClass")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(class)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_DeleteClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteClass'
+type MockCUPSClientInterface_DeleteClass_Call struct {
+	*mock.Call
+}
+
+// DeleteClass is a helper method to define mock.On call
+//   - class string
+func (_e *MockCUPSClientInterface_Expecter) DeleteClass(class interface{}) *MockCUPSClientInterface_DeleteClass_Call {
+	return &MockCUPSClientInterface_DeleteClass_Call{Call: _e.mock.On("DeleteClass", class)}
+}
+
+func (_c *MockCUPSClientInterface_DeleteClass_Call) Run(run func(class string)) *MockCUPSClientInterface_DeleteClass_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_DeleteClass_Call) Return(_a0 error) *MockCUPSClientInterface_DeleteClass_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_DeleteClass_Call) RunAndReturn(run func(string) error) *MockCUPSClientInterface_DeleteClass_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeletePrinter provides a mock function with given fields: printer
+func (_m *MockCUPSClientInterface) DeletePrinter(printer string) error {
+	ret := _m.Called(printer)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeletePrinter")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(printer)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_DeletePrinter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePrinter'
+type MockCUPSClientInterface_DeletePrinter_Call struct {
+	*mock.Call
+}
+
+// DeletePrinter is a helper method to define mock.On call
+//   - printer string
+func (_e *MockCUPSClientInterface_Expecter) DeletePrinter(printer interface{}) *MockCUPSClientInterface_DeletePrinter_Call {
+	return &MockCUPSClientInterface_DeletePrinter_Call{Call: _e.mock.On("DeletePrinter", printer)}
+}
+
+func (_c *MockCUPSClientInterface_DeletePrinter_Call) Run(run func(printer string)) *MockCUPSClientInterface_DeletePrinter_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_DeletePrinter_Call) Return(_a0 error) *MockCUPSClientInterface_DeletePrinter_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_DeletePrinter_Call) RunAndReturn(run func(string) error) *MockCUPSClientInterface_DeletePrinter_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeletePrinterFromClass provides a mock function with given fields: class, printer
+func (_m *MockCUPSClientInterface) DeletePrinterFromClass(class string, printer string) error {
+	ret := _m.Called(class, printer)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeletePrinterFromClass")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(class, printer)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_DeletePrinterFromClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePrinterFromClass'
+type MockCUPSClientInterface_DeletePrinterFromClass_Call struct {
+	*mock.Call
+}
+
+// DeletePrinterFromClass is a helper method to define mock.On call
+//   - class string
+//   - printer string
+func (_e *MockCUPSClientInterface_Expecter) DeletePrinterFromClass(class interface{}, printer interface{}) *MockCUPSClientInterface_DeletePrinterFromClass_Call {
+	return &MockCUPSClientInterface_DeletePrinterFromClass_Call{Call: _e.mock.On("DeletePrinterFromClass", class, printer)}
+}
+
+func (_c *MockCUPSClientInterface_DeletePrinterFromClass_Call) Run(run func(class string, printer string)) *MockCUPSClientInterface_DeletePrinterFromClass_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_DeletePrinterFromClass_Call) Return(_a0 error) *MockCUPSClientInterface_DeletePrinterFromClass_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_DeletePrinterFromClass_Call) RunAndReturn(run func(string, string) error) *MockCUPSClientInterface_DeletePrinterFromClass_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetClasses provides a mock function with given fields: attributes
+func (_m *MockCUPSClientInterface) GetClasses(attributes []string) (map[string]ipp.Attributes, error) {
+	ret := _m.Called(attributes)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetClasses")
+	}
+
+	var r0 map[string]ipp.Attributes
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]string) (map[string]ipp.Attributes, error)); ok {
+		return rf(attributes)
+	}
+	if rf, ok := ret.Get(0).(func([]string) map[string]ipp.Attributes); ok {
+		r0 = rf(attributes)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]ipp.Attributes)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]string) error); ok {
+		r1 = rf(attributes)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockCUPSClientInterface_GetClasses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClasses'
+type MockCUPSClientInterface_GetClasses_Call struct {
+	*mock.Call
+}
+
+// GetClasses is a helper method to define mock.On call
+//   - attributes []string
+func (_e *MockCUPSClientInterface_Expecter) GetClasses(attributes interface{}) *MockCUPSClientInterface_GetClasses_Call {
+	return &MockCUPSClientInterface_GetClasses_Call{Call: _e.mock.On("GetClasses", attributes)}
+}
+
+func (_c *MockCUPSClientInterface_GetClasses_Call) Run(run func(attributes []string)) *MockCUPSClientInterface_GetClasses_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].([]string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_GetClasses_Call) Return(_a0 map[string]ipp.Attributes, _a1 error) *MockCUPSClientInterface_GetClasses_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_GetClasses_Call) RunAndReturn(run func([]string) (map[string]ipp.Attributes, error)) *MockCUPSClientInterface_GetClasses_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetDevices provides a mock function with no fields
+func (_m *MockCUPSClientInterface) GetDevices() (map[string]ipp.Attributes, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetDevices")
+	}
+
+	var r0 map[string]ipp.Attributes
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (map[string]ipp.Attributes, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() map[string]ipp.Attributes); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]ipp.Attributes)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockCUPSClientInterface_GetDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDevices'
+type MockCUPSClientInterface_GetDevices_Call struct {
+	*mock.Call
+}
+
+// GetDevices is a helper method to define mock.On call
+func (_e *MockCUPSClientInterface_Expecter) GetDevices() *MockCUPSClientInterface_GetDevices_Call {
+	return &MockCUPSClientInterface_GetDevices_Call{Call: _e.mock.On("GetDevices")}
+}
+
+func (_c *MockCUPSClientInterface_GetDevices_Call) Run(run func()) *MockCUPSClientInterface_GetDevices_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_GetDevices_Call) Return(_a0 map[string]ipp.Attributes, _a1 error) *MockCUPSClientInterface_GetDevices_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_GetDevices_Call) RunAndReturn(run func() (map[string]ipp.Attributes, error)) *MockCUPSClientInterface_GetDevices_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetJobs provides a mock function with given fields: printer, class, whichJobs, myJobs, firstJobId, limit, attributes
+func (_m *MockCUPSClientInterface) GetJobs(printer string, class string, whichJobs string, myJobs bool, firstJobId int, limit int, attributes []string) (map[int]ipp.Attributes, error) {
+	ret := _m.Called(printer, class, whichJobs, myJobs, firstJobId, limit, attributes)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetJobs")
+	}
+
+	var r0 map[int]ipp.Attributes
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, string, bool, int, int, []string) (map[int]ipp.Attributes, error)); ok {
+		return rf(printer, class, whichJobs, myJobs, firstJobId, limit, attributes)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, string, bool, int, int, []string) map[int]ipp.Attributes); ok {
+		r0 = rf(printer, class, whichJobs, myJobs, firstJobId, limit, attributes)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[int]ipp.Attributes)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, string, bool, int, int, []string) error); ok {
+		r1 = rf(printer, class, whichJobs, myJobs, firstJobId, limit, attributes)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockCUPSClientInterface_GetJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetJobs'
+type MockCUPSClientInterface_GetJobs_Call struct {
+	*mock.Call
+}
+
+// GetJobs is a helper method to define mock.On call
+//   - printer string
+//   - class string
+//   - whichJobs string
+//   - myJobs bool
+//   - firstJobId int
+//   - limit int
+//   - attributes []string
+func (_e *MockCUPSClientInterface_Expecter) GetJobs(printer interface{}, class interface{}, whichJobs interface{}, myJobs interface{}, firstJobId interface{}, limit interface{}, attributes interface{}) *MockCUPSClientInterface_GetJobs_Call {
+	return &MockCUPSClientInterface_GetJobs_Call{Call: _e.mock.On("GetJobs", printer, class, whichJobs, myJobs, firstJobId, limit, attributes)}
+}
+
+func (_c *MockCUPSClientInterface_GetJobs_Call) Run(run func(printer string, class string, whichJobs string, myJobs bool, firstJobId int, limit int, attributes []string)) *MockCUPSClientInterface_GetJobs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string), args[2].(string), args[3].(bool), args[4].(int), args[5].(int), args[6].([]string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_GetJobs_Call) Return(_a0 map[int]ipp.Attributes, _a1 error) *MockCUPSClientInterface_GetJobs_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_GetJobs_Call) RunAndReturn(run func(string, string, string, bool, int, int, []string) (map[int]ipp.Attributes, error)) *MockCUPSClientInterface_GetJobs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPPDs provides a mock function with no fields
+func (_m *MockCUPSClientInterface) GetPPDs() (map[string]ipp.Attributes, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPPDs")
+	}
+
+	var r0 map[string]ipp.Attributes
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (map[string]ipp.Attributes, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() map[string]ipp.Attributes); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]ipp.Attributes)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockCUPSClientInterface_GetPPDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPPDs'
+type MockCUPSClientInterface_GetPPDs_Call struct {
+	*mock.Call
+}
+
+// GetPPDs is a helper method to define mock.On call
+func (_e *MockCUPSClientInterface_Expecter) GetPPDs() *MockCUPSClientInterface_GetPPDs_Call {
+	return &MockCUPSClientInterface_GetPPDs_Call{Call: _e.mock.On("GetPPDs")}
+}
+
+func (_c *MockCUPSClientInterface_GetPPDs_Call) Run(run func()) *MockCUPSClientInterface_GetPPDs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_GetPPDs_Call) Return(_a0 map[string]ipp.Attributes, _a1 error) *MockCUPSClientInterface_GetPPDs_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_GetPPDs_Call) RunAndReturn(run func() (map[string]ipp.Attributes, error)) *MockCUPSClientInterface_GetPPDs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPrinters provides a mock function with given fields: attributes
+func (_m *MockCUPSClientInterface) GetPrinters(attributes []string) (map[string]ipp.Attributes, error) {
+	ret := _m.Called(attributes)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPrinters")
+	}
+
+	var r0 map[string]ipp.Attributes
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]string) (map[string]ipp.Attributes, error)); ok {
+		return rf(attributes)
+	}
+	if rf, ok := ret.Get(0).(func([]string) map[string]ipp.Attributes); ok {
+		r0 = rf(attributes)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[string]ipp.Attributes)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]string) error); ok {
+		r1 = rf(attributes)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockCUPSClientInterface_GetPrinters_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPrinters'
+type MockCUPSClientInterface_GetPrinters_Call struct {
+	*mock.Call
+}
+
+// GetPrinters is a helper method to define mock.On call
+//   - attributes []string
+func (_e *MockCUPSClientInterface_Expecter) GetPrinters(attributes interface{}) *MockCUPSClientInterface_GetPrinters_Call {
+	return &MockCUPSClientInterface_GetPrinters_Call{Call: _e.mock.On("GetPrinters", attributes)}
+}
+
+func (_c *MockCUPSClientInterface_GetPrinters_Call) Run(run func(attributes []string)) *MockCUPSClientInterface_GetPrinters_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].([]string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_GetPrinters_Call) Return(_a0 map[string]ipp.Attributes, _a1 error) *MockCUPSClientInterface_GetPrinters_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_GetPrinters_Call) RunAndReturn(run func([]string) (map[string]ipp.Attributes, error)) *MockCUPSClientInterface_GetPrinters_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// HoldJobUntil provides a mock function with given fields: jobID, holdUntil
+func (_m *MockCUPSClientInterface) HoldJobUntil(jobID int, holdUntil string) error {
+	ret := _m.Called(jobID, holdUntil)
+
+	if len(ret) == 0 {
+		panic("no return value specified for HoldJobUntil")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(int, string) error); ok {
+		r0 = rf(jobID, holdUntil)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_HoldJobUntil_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HoldJobUntil'
+type MockCUPSClientInterface_HoldJobUntil_Call struct {
+	*mock.Call
+}
+
+// HoldJobUntil is a helper method to define mock.On call
+//   - jobID int
+//   - holdUntil string
+func (_e *MockCUPSClientInterface_Expecter) HoldJobUntil(jobID interface{}, holdUntil interface{}) *MockCUPSClientInterface_HoldJobUntil_Call {
+	return &MockCUPSClientInterface_HoldJobUntil_Call{Call: _e.mock.On("HoldJobUntil", jobID, holdUntil)}
+}
+
+func (_c *MockCUPSClientInterface_HoldJobUntil_Call) Run(run func(jobID int, holdUntil string)) *MockCUPSClientInterface_HoldJobUntil_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(int), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_HoldJobUntil_Call) Return(_a0 error) *MockCUPSClientInterface_HoldJobUntil_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_HoldJobUntil_Call) RunAndReturn(run func(int, string) error) *MockCUPSClientInterface_HoldJobUntil_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// MoveJob provides a mock function with given fields: jobID, destPrinter
+func (_m *MockCUPSClientInterface) MoveJob(jobID int, destPrinter string) error {
+	ret := _m.Called(jobID, destPrinter)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MoveJob")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(int, string) error); ok {
+		r0 = rf(jobID, destPrinter)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_MoveJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MoveJob'
+type MockCUPSClientInterface_MoveJob_Call struct {
+	*mock.Call
+}
+
+// MoveJob is a helper method to define mock.On call
+//   - jobID int
+//   - destPrinter string
+func (_e *MockCUPSClientInterface_Expecter) MoveJob(jobID interface{}, destPrinter interface{}) *MockCUPSClientInterface_MoveJob_Call {
+	return &MockCUPSClientInterface_MoveJob_Call{Call: _e.mock.On("MoveJob", jobID, destPrinter)}
+}
+
+func (_c *MockCUPSClientInterface_MoveJob_Call) Run(run func(jobID int, destPrinter string)) *MockCUPSClientInterface_MoveJob_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(int), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_MoveJob_Call) Return(_a0 error) *MockCUPSClientInterface_MoveJob_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_MoveJob_Call) RunAndReturn(run func(int, string) error) *MockCUPSClientInterface_MoveJob_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// PausePrinter provides a mock function with given fields: printer
+func (_m *MockCUPSClientInterface) PausePrinter(printer string) error {
+	ret := _m.Called(printer)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PausePrinter")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(printer)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_PausePrinter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PausePrinter'
+type MockCUPSClientInterface_PausePrinter_Call struct {
+	*mock.Call
+}
+
+// PausePrinter is a helper method to define mock.On call
+//   - printer string
+func (_e *MockCUPSClientInterface_Expecter) PausePrinter(printer interface{}) *MockCUPSClientInterface_PausePrinter_Call {
+	return &MockCUPSClientInterface_PausePrinter_Call{Call: _e.mock.On("PausePrinter", printer)}
+}
+
+func (_c *MockCUPSClientInterface_PausePrinter_Call) Run(run func(printer string)) *MockCUPSClientInterface_PausePrinter_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_PausePrinter_Call) Return(_a0 error) *MockCUPSClientInterface_PausePrinter_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_PausePrinter_Call) RunAndReturn(run func(string) error) *MockCUPSClientInterface_PausePrinter_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// PrintTestPage provides a mock function with given fields: printer, testPageData, size
+func (_m *MockCUPSClientInterface) PrintTestPage(printer string, testPageData io.Reader, size int) (int, error) {
+	ret := _m.Called(printer, testPageData, size)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PrintTestPage")
+	}
+
+	var r0 int
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, io.Reader, int) (int, error)); ok {
+		return rf(printer, testPageData, size)
+	}
+	if rf, ok := ret.Get(0).(func(string, io.Reader, int) int); ok {
+		r0 = rf(printer, testPageData, size)
+	} else {
+		r0 = ret.Get(0).(int)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, io.Reader, int) error); ok {
+		r1 = rf(printer, testPageData, size)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockCUPSClientInterface_PrintTestPage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrintTestPage'
+type MockCUPSClientInterface_PrintTestPage_Call struct {
+	*mock.Call
+}
+
+// PrintTestPage is a helper method to define mock.On call
+//   - printer string
+//   - testPageData io.Reader
+//   - size int
+func (_e *MockCUPSClientInterface_Expecter) PrintTestPage(printer interface{}, testPageData interface{}, size interface{}) *MockCUPSClientInterface_PrintTestPage_Call {
+	return &MockCUPSClientInterface_PrintTestPage_Call{Call: _e.mock.On("PrintTestPage", printer, testPageData, size)}
+}
+
+func (_c *MockCUPSClientInterface_PrintTestPage_Call) Run(run func(printer string, testPageData io.Reader, size int)) *MockCUPSClientInterface_PrintTestPage_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(io.Reader), args[2].(int))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_PrintTestPage_Call) Return(_a0 int, _a1 error) *MockCUPSClientInterface_PrintTestPage_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_PrintTestPage_Call) RunAndReturn(run func(string, io.Reader, int) (int, error)) *MockCUPSClientInterface_PrintTestPage_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RejectJobs provides a mock function with given fields: printer
+func (_m *MockCUPSClientInterface) RejectJobs(printer string) error {
+	ret := _m.Called(printer)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RejectJobs")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(printer)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_RejectJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RejectJobs'
+type MockCUPSClientInterface_RejectJobs_Call struct {
+	*mock.Call
+}
+
+// RejectJobs is a helper method to define mock.On call
+//   - printer string
+func (_e *MockCUPSClientInterface_Expecter) RejectJobs(printer interface{}) *MockCUPSClientInterface_RejectJobs_Call {
+	return &MockCUPSClientInterface_RejectJobs_Call{Call: _e.mock.On("RejectJobs", printer)}
+}
+
+func (_c *MockCUPSClientInterface_RejectJobs_Call) Run(run func(printer string)) *MockCUPSClientInterface_RejectJobs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_RejectJobs_Call) Return(_a0 error) *MockCUPSClientInterface_RejectJobs_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_RejectJobs_Call) RunAndReturn(run func(string) error) *MockCUPSClientInterface_RejectJobs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RestartJob provides a mock function with given fields: jobID
+func (_m *MockCUPSClientInterface) RestartJob(jobID int) error {
+	ret := _m.Called(jobID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RestartJob")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(int) error); ok {
+		r0 = rf(jobID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_RestartJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestartJob'
+type MockCUPSClientInterface_RestartJob_Call struct {
+	*mock.Call
+}
+
+// RestartJob is a helper method to define mock.On call
+//   - jobID int
+func (_e *MockCUPSClientInterface_Expecter) RestartJob(jobID interface{}) *MockCUPSClientInterface_RestartJob_Call {
+	return &MockCUPSClientInterface_RestartJob_Call{Call: _e.mock.On("RestartJob", jobID)}
+}
+
+func (_c *MockCUPSClientInterface_RestartJob_Call) Run(run func(jobID int)) *MockCUPSClientInterface_RestartJob_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(int))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_RestartJob_Call) Return(_a0 error) *MockCUPSClientInterface_RestartJob_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_RestartJob_Call) RunAndReturn(run func(int) error) *MockCUPSClientInterface_RestartJob_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ResumePrinter provides a mock function with given fields: printer
+func (_m *MockCUPSClientInterface) ResumePrinter(printer string) error {
+	ret := _m.Called(printer)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ResumePrinter")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(printer)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_ResumePrinter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResumePrinter'
+type MockCUPSClientInterface_ResumePrinter_Call struct {
+	*mock.Call
+}
+
+// ResumePrinter is a helper method to define mock.On call
+//   - printer string
+func (_e *MockCUPSClientInterface_Expecter) ResumePrinter(printer interface{}) *MockCUPSClientInterface_ResumePrinter_Call {
+	return &MockCUPSClientInterface_ResumePrinter_Call{Call: _e.mock.On("ResumePrinter", printer)}
+}
+
+func (_c *MockCUPSClientInterface_ResumePrinter_Call) Run(run func(printer string)) *MockCUPSClientInterface_ResumePrinter_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_ResumePrinter_Call) Return(_a0 error) *MockCUPSClientInterface_ResumePrinter_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_ResumePrinter_Call) RunAndReturn(run func(string) error) *MockCUPSClientInterface_ResumePrinter_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SendRequest provides a mock function with given fields: url, req, additionalResponseData
+func (_m *MockCUPSClientInterface) SendRequest(url string, req *ipp.Request, additionalResponseData io.Writer) (*ipp.Response, error) {
+	ret := _m.Called(url, req, additionalResponseData)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SendRequest")
+	}
+
+	var r0 *ipp.Response
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, *ipp.Request, io.Writer) (*ipp.Response, error)); ok {
+		return rf(url, req, additionalResponseData)
+	}
+	if rf, ok := ret.Get(0).(func(string, *ipp.Request, io.Writer) *ipp.Response); ok {
+		r0 = rf(url, req, additionalResponseData)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*ipp.Response)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, *ipp.Request, io.Writer) error); ok {
+		r1 = rf(url, req, additionalResponseData)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockCUPSClientInterface_SendRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendRequest'
+type MockCUPSClientInterface_SendRequest_Call struct {
+	*mock.Call
+}
+
+// SendRequest is a helper method to define mock.On call
+//   - url string
+//   - req *ipp.Request
+//   - additionalResponseData io.Writer
+func (_e *MockCUPSClientInterface_Expecter) SendRequest(url interface{}, req interface{}, additionalResponseData interface{}) *MockCUPSClientInterface_SendRequest_Call {
+	return &MockCUPSClientInterface_SendRequest_Call{Call: _e.mock.On("SendRequest", url, req, additionalResponseData)}
+}
+
+func (_c *MockCUPSClientInterface_SendRequest_Call) Run(run func(url string, req *ipp.Request, additionalResponseData io.Writer)) *MockCUPSClientInterface_SendRequest_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(*ipp.Request), args[2].(io.Writer))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_SendRequest_Call) Return(_a0 *ipp.Response, _a1 error) *MockCUPSClientInterface_SendRequest_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_SendRequest_Call) RunAndReturn(run func(string, *ipp.Request, io.Writer) (*ipp.Response, error)) *MockCUPSClientInterface_SendRequest_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetPrinterInformation provides a mock function with given fields: printer, information
+func (_m *MockCUPSClientInterface) SetPrinterInformation(printer string, information string) error {
+	ret := _m.Called(printer, information)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetPrinterInformation")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(printer, information)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_SetPrinterInformation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPrinterInformation'
+type MockCUPSClientInterface_SetPrinterInformation_Call struct {
+	*mock.Call
+}
+
+// SetPrinterInformation is a helper method to define mock.On call
+//   - printer string
+//   - information string
+func (_e *MockCUPSClientInterface_Expecter) SetPrinterInformation(printer interface{}, information interface{}) *MockCUPSClientInterface_SetPrinterInformation_Call {
+	return &MockCUPSClientInterface_SetPrinterInformation_Call{Call: _e.mock.On("SetPrinterInformation", printer, information)}
+}
+
+func (_c *MockCUPSClientInterface_SetPrinterInformation_Call) Run(run func(printer string, information string)) *MockCUPSClientInterface_SetPrinterInformation_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_SetPrinterInformation_Call) Return(_a0 error) *MockCUPSClientInterface_SetPrinterInformation_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_SetPrinterInformation_Call) RunAndReturn(run func(string, string) error) *MockCUPSClientInterface_SetPrinterInformation_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetPrinterIsShared provides a mock function with given fields: printer, shared
+func (_m *MockCUPSClientInterface) SetPrinterIsShared(printer string, shared bool) error {
+	ret := _m.Called(printer, shared)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetPrinterIsShared")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, bool) error); ok {
+		r0 = rf(printer, shared)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_SetPrinterIsShared_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPrinterIsShared'
+type MockCUPSClientInterface_SetPrinterIsShared_Call struct {
+	*mock.Call
+}
+
+// SetPrinterIsShared is a helper method to define mock.On call
+//   - printer string
+//   - shared bool
+func (_e *MockCUPSClientInterface_Expecter) SetPrinterIsShared(printer interface{}, shared interface{}) *MockCUPSClientInterface_SetPrinterIsShared_Call {
+	return &MockCUPSClientInterface_SetPrinterIsShared_Call{Call: _e.mock.On("SetPrinterIsShared", printer, shared)}
+}
+
+func (_c *MockCUPSClientInterface_SetPrinterIsShared_Call) Run(run func(printer string, shared bool)) *MockCUPSClientInterface_SetPrinterIsShared_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(bool))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_SetPrinterIsShared_Call) Return(_a0 error) *MockCUPSClientInterface_SetPrinterIsShared_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_SetPrinterIsShared_Call) RunAndReturn(run func(string, bool) error) *MockCUPSClientInterface_SetPrinterIsShared_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetPrinterLocation provides a mock function with given fields: printer, location
+func (_m *MockCUPSClientInterface) SetPrinterLocation(printer string, location string) error {
+	ret := _m.Called(printer, location)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetPrinterLocation")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(printer, location)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockCUPSClientInterface_SetPrinterLocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPrinterLocation'
+type MockCUPSClientInterface_SetPrinterLocation_Call struct {
+	*mock.Call
+}
+
+// SetPrinterLocation is a helper method to define mock.On call
+//   - printer string
+//   - location string
+func (_e *MockCUPSClientInterface_Expecter) SetPrinterLocation(printer interface{}, location interface{}) *MockCUPSClientInterface_SetPrinterLocation_Call {
+	return &MockCUPSClientInterface_SetPrinterLocation_Call{Call: _e.mock.On("SetPrinterLocation", printer, location)}
+}
+
+func (_c *MockCUPSClientInterface_SetPrinterLocation_Call) Run(run func(printer string, location string)) *MockCUPSClientInterface_SetPrinterLocation_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_SetPrinterLocation_Call) Return(_a0 error) *MockCUPSClientInterface_SetPrinterLocation_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockCUPSClientInterface_SetPrinterLocation_Call) RunAndReturn(run func(string, string) error) *MockCUPSClientInterface_SetPrinterLocation_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockCUPSClientInterface creates a new instance of MockCUPSClientInterface. 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 NewMockCUPSClientInterface(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockCUPSClientInterface {
+	mock := &MockCUPSClientInterface{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/cups_pkhelper/mock_PkHelper.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/cups_pkhelper/mock_PkHelper.go
new file mode 100644
index 0000000..cad5bfc
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/cups_pkhelper/mock_PkHelper.go
@@ -0,0 +1,708 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package mocks_cups_pkhelper
+
+import (
+	cups "github.com/AvengeMedia/DankMaterialShell/core/internal/server/cups"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockPkHelper is an autogenerated mock type for the PkHelper type
+type MockPkHelper struct {
+	mock.Mock
+}
+
+type MockPkHelper_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockPkHelper) EXPECT() *MockPkHelper_Expecter {
+	return &MockPkHelper_Expecter{mock: &_m.Mock}
+}
+
+// ClassAddPrinter provides a mock function with given fields: className, printerName
+func (_m *MockPkHelper) ClassAddPrinter(className string, printerName string) error {
+	ret := _m.Called(className, printerName)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ClassAddPrinter")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(className, printerName)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockPkHelper_ClassAddPrinter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClassAddPrinter'
+type MockPkHelper_ClassAddPrinter_Call struct {
+	*mock.Call
+}
+
+// ClassAddPrinter is a helper method to define mock.On call
+//   - className string
+//   - printerName string
+func (_e *MockPkHelper_Expecter) ClassAddPrinter(className interface{}, printerName interface{}) *MockPkHelper_ClassAddPrinter_Call {
+	return &MockPkHelper_ClassAddPrinter_Call{Call: _e.mock.On("ClassAddPrinter", className, printerName)}
+}
+
+func (_c *MockPkHelper_ClassAddPrinter_Call) Run(run func(className string, printerName string)) *MockPkHelper_ClassAddPrinter_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockPkHelper_ClassAddPrinter_Call) Return(_a0 error) *MockPkHelper_ClassAddPrinter_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockPkHelper_ClassAddPrinter_Call) RunAndReturn(run func(string, string) error) *MockPkHelper_ClassAddPrinter_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ClassDelete provides a mock function with given fields: className
+func (_m *MockPkHelper) ClassDelete(className string) error {
+	ret := _m.Called(className)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ClassDelete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(className)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockPkHelper_ClassDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClassDelete'
+type MockPkHelper_ClassDelete_Call struct {
+	*mock.Call
+}
+
+// ClassDelete is a helper method to define mock.On call
+//   - className string
+func (_e *MockPkHelper_Expecter) ClassDelete(className interface{}) *MockPkHelper_ClassDelete_Call {
+	return &MockPkHelper_ClassDelete_Call{Call: _e.mock.On("ClassDelete", className)}
+}
+
+func (_c *MockPkHelper_ClassDelete_Call) Run(run func(className string)) *MockPkHelper_ClassDelete_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockPkHelper_ClassDelete_Call) Return(_a0 error) *MockPkHelper_ClassDelete_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockPkHelper_ClassDelete_Call) RunAndReturn(run func(string) error) *MockPkHelper_ClassDelete_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ClassDeletePrinter provides a mock function with given fields: className, printerName
+func (_m *MockPkHelper) ClassDeletePrinter(className string, printerName string) error {
+	ret := _m.Called(className, printerName)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ClassDeletePrinter")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(className, printerName)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockPkHelper_ClassDeletePrinter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClassDeletePrinter'
+type MockPkHelper_ClassDeletePrinter_Call struct {
+	*mock.Call
+}
+
+// ClassDeletePrinter is a helper method to define mock.On call
+//   - className string
+//   - printerName string
+func (_e *MockPkHelper_Expecter) ClassDeletePrinter(className interface{}, printerName interface{}) *MockPkHelper_ClassDeletePrinter_Call {
+	return &MockPkHelper_ClassDeletePrinter_Call{Call: _e.mock.On("ClassDeletePrinter", className, printerName)}
+}
+
+func (_c *MockPkHelper_ClassDeletePrinter_Call) Run(run func(className string, printerName string)) *MockPkHelper_ClassDeletePrinter_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockPkHelper_ClassDeletePrinter_Call) Return(_a0 error) *MockPkHelper_ClassDeletePrinter_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockPkHelper_ClassDeletePrinter_Call) RunAndReturn(run func(string, string) error) *MockPkHelper_ClassDeletePrinter_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DevicesGet provides a mock function with given fields: timeout, limit, includeSchemes, excludeSchemes
+func (_m *MockPkHelper) DevicesGet(timeout int, limit int, includeSchemes []string, excludeSchemes []string) ([]cups.Device, error) {
+	ret := _m.Called(timeout, limit, includeSchemes, excludeSchemes)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DevicesGet")
+	}
+
+	var r0 []cups.Device
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int, int, []string, []string) ([]cups.Device, error)); ok {
+		return rf(timeout, limit, includeSchemes, excludeSchemes)
+	}
+	if rf, ok := ret.Get(0).(func(int, int, []string, []string) []cups.Device); ok {
+		r0 = rf(timeout, limit, includeSchemes, excludeSchemes)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]cups.Device)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(int, int, []string, []string) error); ok {
+		r1 = rf(timeout, limit, includeSchemes, excludeSchemes)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockPkHelper_DevicesGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DevicesGet'
+type MockPkHelper_DevicesGet_Call struct {
+	*mock.Call
+}
+
+// DevicesGet is a helper method to define mock.On call
+//   - timeout int
+//   - limit int
+//   - includeSchemes []string
+//   - excludeSchemes []string
+func (_e *MockPkHelper_Expecter) DevicesGet(timeout interface{}, limit interface{}, includeSchemes interface{}, excludeSchemes interface{}) *MockPkHelper_DevicesGet_Call {
+	return &MockPkHelper_DevicesGet_Call{Call: _e.mock.On("DevicesGet", timeout, limit, includeSchemes, excludeSchemes)}
+}
+
+func (_c *MockPkHelper_DevicesGet_Call) Run(run func(timeout int, limit int, includeSchemes []string, excludeSchemes []string)) *MockPkHelper_DevicesGet_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(int), args[1].(int), args[2].([]string), args[3].([]string))
+	})
+	return _c
+}
+
+func (_c *MockPkHelper_DevicesGet_Call) Return(_a0 []cups.Device, _a1 error) *MockPkHelper_DevicesGet_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockPkHelper_DevicesGet_Call) RunAndReturn(run func(int, int, []string, []string) ([]cups.Device, error)) *MockPkHelper_DevicesGet_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// JobCancelPurge provides a mock function with given fields: jobID, purge
+func (_m *MockPkHelper) JobCancelPurge(jobID int, purge bool) error {
+	ret := _m.Called(jobID, purge)
+
+	if len(ret) == 0 {
+		panic("no return value specified for JobCancelPurge")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(int, bool) error); ok {
+		r0 = rf(jobID, purge)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockPkHelper_JobCancelPurge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JobCancelPurge'
+type MockPkHelper_JobCancelPurge_Call struct {
+	*mock.Call
+}
+
+// JobCancelPurge is a helper method to define mock.On call
+//   - jobID int
+//   - purge bool
+func (_e *MockPkHelper_Expecter) JobCancelPurge(jobID interface{}, purge interface{}) *MockPkHelper_JobCancelPurge_Call {
+	return &MockPkHelper_JobCancelPurge_Call{Call: _e.mock.On("JobCancelPurge", jobID, purge)}
+}
+
+func (_c *MockPkHelper_JobCancelPurge_Call) Run(run func(jobID int, purge bool)) *MockPkHelper_JobCancelPurge_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(int), args[1].(bool))
+	})
+	return _c
+}
+
+func (_c *MockPkHelper_JobCancelPurge_Call) Return(_a0 error) *MockPkHelper_JobCancelPurge_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockPkHelper_JobCancelPurge_Call) RunAndReturn(run func(int, bool) error) *MockPkHelper_JobCancelPurge_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// JobRestart provides a mock function with given fields: jobID
+func (_m *MockPkHelper) JobRestart(jobID int) error {
+	ret := _m.Called(jobID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for JobRestart")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(int) error); ok {
+		r0 = rf(jobID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockPkHelper_JobRestart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JobRestart'
+type MockPkHelper_JobRestart_Call struct {
+	*mock.Call
+}
+
+// JobRestart is a helper method to define mock.On call
+//   - jobID int
+func (_e *MockPkHelper_Expecter) JobRestart(jobID interface{}) *MockPkHelper_JobRestart_Call {
+	return &MockPkHelper_JobRestart_Call{Call: _e.mock.On("JobRestart", jobID)}
+}
+
+func (_c *MockPkHelper_JobRestart_Call) Run(run func(jobID int)) *MockPkHelper_JobRestart_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(int))
+	})
+	return _c
+}
+
+func (_c *MockPkHelper_JobRestart_Call) Return(_a0 error) *MockPkHelper_JobRestart_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockPkHelper_JobRestart_Call) RunAndReturn(run func(int) error) *MockPkHelper_JobRestart_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// JobSetHoldUntil provides a mock function with given fields: jobID, holdUntil
+func (_m *MockPkHelper) JobSetHoldUntil(jobID int, holdUntil string) error {
+	ret := _m.Called(jobID, holdUntil)
+
+	if len(ret) == 0 {
+		panic("no return value specified for JobSetHoldUntil")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(int, string) error); ok {
+		r0 = rf(jobID, holdUntil)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockPkHelper_JobSetHoldUntil_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JobSetHoldUntil'
+type MockPkHelper_JobSetHoldUntil_Call struct {
+	*mock.Call
+}
+
+// JobSetHoldUntil is a helper method to define mock.On call
+//   - jobID int
+//   - holdUntil string
+func (_e *MockPkHelper_Expecter) JobSetHoldUntil(jobID interface{}, holdUntil interface{}) *MockPkHelper_JobSetHoldUntil_Call {
+	return &MockPkHelper_JobSetHoldUntil_Call{Call: _e.mock.On("JobSetHoldUntil", jobID, holdUntil)}
+}
+
+func (_c *MockPkHelper_JobSetHoldUntil_Call) Run(run func(jobID int, holdUntil string)) *MockPkHelper_JobSetHoldUntil_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(int), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockPkHelper_JobSetHoldUntil_Call) Return(_a0 error) *MockPkHelper_JobSetHoldUntil_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockPkHelper_JobSetHoldUntil_Call) RunAndReturn(run func(int, string) error) *MockPkHelper_JobSetHoldUntil_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// PrinterAdd provides a mock function with given fields: name, uri, ppd, info, location
+func (_m *MockPkHelper) PrinterAdd(name string, uri string, ppd string, info string, location string) error {
+	ret := _m.Called(name, uri, ppd, info, location)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PrinterAdd")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string, string, string, string) error); ok {
+		r0 = rf(name, uri, ppd, info, location)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockPkHelper_PrinterAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrinterAdd'
+type MockPkHelper_PrinterAdd_Call struct {
+	*mock.Call
+}
+
+// PrinterAdd is a helper method to define mock.On call
+//   - name string
+//   - uri string
+//   - ppd string
+//   - info string
+//   - location string
+func (_e *MockPkHelper_Expecter) PrinterAdd(name interface{}, uri interface{}, ppd interface{}, info interface{}, location interface{}) *MockPkHelper_PrinterAdd_Call {
+	return &MockPkHelper_PrinterAdd_Call{Call: _e.mock.On("PrinterAdd", name, uri, ppd, info, location)}
+}
+
+func (_c *MockPkHelper_PrinterAdd_Call) Run(run func(name string, uri string, ppd string, info string, location string)) *MockPkHelper_PrinterAdd_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
+	})
+	return _c
+}
+
+func (_c *MockPkHelper_PrinterAdd_Call) Return(_a0 error) *MockPkHelper_PrinterAdd_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockPkHelper_PrinterAdd_Call) RunAndReturn(run func(string, string, string, string, string) error) *MockPkHelper_PrinterAdd_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// PrinterDelete provides a mock function with given fields: name
+func (_m *MockPkHelper) PrinterDelete(name string) error {
+	ret := _m.Called(name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PrinterDelete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(name)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockPkHelper_PrinterDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrinterDelete'
+type MockPkHelper_PrinterDelete_Call struct {
+	*mock.Call
+}
+
+// PrinterDelete is a helper method to define mock.On call
+//   - name string
+func (_e *MockPkHelper_Expecter) PrinterDelete(name interface{}) *MockPkHelper_PrinterDelete_Call {
+	return &MockPkHelper_PrinterDelete_Call{Call: _e.mock.On("PrinterDelete", name)}
+}
+
+func (_c *MockPkHelper_PrinterDelete_Call) Run(run func(name string)) *MockPkHelper_PrinterDelete_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockPkHelper_PrinterDelete_Call) Return(_a0 error) *MockPkHelper_PrinterDelete_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockPkHelper_PrinterDelete_Call) RunAndReturn(run func(string) error) *MockPkHelper_PrinterDelete_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// PrinterSetAcceptJobs provides a mock function with given fields: name, enabled, reason
+func (_m *MockPkHelper) PrinterSetAcceptJobs(name string, enabled bool, reason string) error {
+	ret := _m.Called(name, enabled, reason)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PrinterSetAcceptJobs")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, bool, string) error); ok {
+		r0 = rf(name, enabled, reason)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockPkHelper_PrinterSetAcceptJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrinterSetAcceptJobs'
+type MockPkHelper_PrinterSetAcceptJobs_Call struct {
+	*mock.Call
+}
+
+// PrinterSetAcceptJobs is a helper method to define mock.On call
+//   - name string
+//   - enabled bool
+//   - reason string
+func (_e *MockPkHelper_Expecter) PrinterSetAcceptJobs(name interface{}, enabled interface{}, reason interface{}) *MockPkHelper_PrinterSetAcceptJobs_Call {
+	return &MockPkHelper_PrinterSetAcceptJobs_Call{Call: _e.mock.On("PrinterSetAcceptJobs", name, enabled, reason)}
+}
+
+func (_c *MockPkHelper_PrinterSetAcceptJobs_Call) Run(run func(name string, enabled bool, reason string)) *MockPkHelper_PrinterSetAcceptJobs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(bool), args[2].(string))
+	})
+	return _c
+}
+
+func (_c *MockPkHelper_PrinterSetAcceptJobs_Call) Return(_a0 error) *MockPkHelper_PrinterSetAcceptJobs_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockPkHelper_PrinterSetAcceptJobs_Call) RunAndReturn(run func(string, bool, string) error) *MockPkHelper_PrinterSetAcceptJobs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// PrinterSetEnabled provides a mock function with given fields: name, enabled
+func (_m *MockPkHelper) PrinterSetEnabled(name string, enabled bool) error {
+	ret := _m.Called(name, enabled)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PrinterSetEnabled")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, bool) error); ok {
+		r0 = rf(name, enabled)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockPkHelper_PrinterSetEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrinterSetEnabled'
+type MockPkHelper_PrinterSetEnabled_Call struct {
+	*mock.Call
+}
+
+// PrinterSetEnabled is a helper method to define mock.On call
+//   - name string
+//   - enabled bool
+func (_e *MockPkHelper_Expecter) PrinterSetEnabled(name interface{}, enabled interface{}) *MockPkHelper_PrinterSetEnabled_Call {
+	return &MockPkHelper_PrinterSetEnabled_Call{Call: _e.mock.On("PrinterSetEnabled", name, enabled)}
+}
+
+func (_c *MockPkHelper_PrinterSetEnabled_Call) Run(run func(name string, enabled bool)) *MockPkHelper_PrinterSetEnabled_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(bool))
+	})
+	return _c
+}
+
+func (_c *MockPkHelper_PrinterSetEnabled_Call) Return(_a0 error) *MockPkHelper_PrinterSetEnabled_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockPkHelper_PrinterSetEnabled_Call) RunAndReturn(run func(string, bool) error) *MockPkHelper_PrinterSetEnabled_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// PrinterSetInfo provides a mock function with given fields: name, info
+func (_m *MockPkHelper) PrinterSetInfo(name string, info string) error {
+	ret := _m.Called(name, info)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PrinterSetInfo")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(name, info)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockPkHelper_PrinterSetInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrinterSetInfo'
+type MockPkHelper_PrinterSetInfo_Call struct {
+	*mock.Call
+}
+
+// PrinterSetInfo is a helper method to define mock.On call
+//   - name string
+//   - info string
+func (_e *MockPkHelper_Expecter) PrinterSetInfo(name interface{}, info interface{}) *MockPkHelper_PrinterSetInfo_Call {
+	return &MockPkHelper_PrinterSetInfo_Call{Call: _e.mock.On("PrinterSetInfo", name, info)}
+}
+
+func (_c *MockPkHelper_PrinterSetInfo_Call) Run(run func(name string, info string)) *MockPkHelper_PrinterSetInfo_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockPkHelper_PrinterSetInfo_Call) Return(_a0 error) *MockPkHelper_PrinterSetInfo_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockPkHelper_PrinterSetInfo_Call) RunAndReturn(run func(string, string) error) *MockPkHelper_PrinterSetInfo_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// PrinterSetLocation provides a mock function with given fields: name, location
+func (_m *MockPkHelper) PrinterSetLocation(name string, location string) error {
+	ret := _m.Called(name, location)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PrinterSetLocation")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(name, location)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockPkHelper_PrinterSetLocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrinterSetLocation'
+type MockPkHelper_PrinterSetLocation_Call struct {
+	*mock.Call
+}
+
+// PrinterSetLocation is a helper method to define mock.On call
+//   - name string
+//   - location string
+func (_e *MockPkHelper_Expecter) PrinterSetLocation(name interface{}, location interface{}) *MockPkHelper_PrinterSetLocation_Call {
+	return &MockPkHelper_PrinterSetLocation_Call{Call: _e.mock.On("PrinterSetLocation", name, location)}
+}
+
+func (_c *MockPkHelper_PrinterSetLocation_Call) Run(run func(name string, location string)) *MockPkHelper_PrinterSetLocation_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockPkHelper_PrinterSetLocation_Call) Return(_a0 error) *MockPkHelper_PrinterSetLocation_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockPkHelper_PrinterSetLocation_Call) RunAndReturn(run func(string, string) error) *MockPkHelper_PrinterSetLocation_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// PrinterSetShared provides a mock function with given fields: name, shared
+func (_m *MockPkHelper) PrinterSetShared(name string, shared bool) error {
+	ret := _m.Called(name, shared)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PrinterSetShared")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, bool) error); ok {
+		r0 = rf(name, shared)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockPkHelper_PrinterSetShared_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrinterSetShared'
+type MockPkHelper_PrinterSetShared_Call struct {
+	*mock.Call
+}
+
+// PrinterSetShared is a helper method to define mock.On call
+//   - name string
+//   - shared bool
+func (_e *MockPkHelper_Expecter) PrinterSetShared(name interface{}, shared interface{}) *MockPkHelper_PrinterSetShared_Call {
+	return &MockPkHelper_PrinterSetShared_Call{Call: _e.mock.On("PrinterSetShared", name, shared)}
+}
+
+func (_c *MockPkHelper_PrinterSetShared_Call) Run(run func(name string, shared bool)) *MockPkHelper_PrinterSetShared_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(bool))
+	})
+	return _c
+}
+
+func (_c *MockPkHelper_PrinterSetShared_Call) Return(_a0 error) *MockPkHelper_PrinterSetShared_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockPkHelper_PrinterSetShared_Call) RunAndReturn(run func(string, bool) error) *MockPkHelper_PrinterSetShared_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockPkHelper creates a new instance of MockPkHelper. 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 NewMockPkHelper(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockPkHelper {
+	mock := &MockPkHelper{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/evdev/mock_EvdevDevice.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/evdev/mock_EvdevDevice.go
new file mode 100644
index 0000000..4d54e3e
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/evdev/mock_EvdevDevice.go
@@ -0,0 +1,295 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package mocks_evdev
+
+import (
+	go_evdev "github.com/holoplot/go-evdev"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockEvdevDevice is an autogenerated mock type for the EvdevDevice type
+type MockEvdevDevice struct {
+	mock.Mock
+}
+
+type MockEvdevDevice_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockEvdevDevice) EXPECT() *MockEvdevDevice_Expecter {
+	return &MockEvdevDevice_Expecter{mock: &_m.Mock}
+}
+
+// Close provides a mock function with no fields
+func (_m *MockEvdevDevice) Close() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Close")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockEvdevDevice_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type MockEvdevDevice_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+func (_e *MockEvdevDevice_Expecter) Close() *MockEvdevDevice_Close_Call {
+	return &MockEvdevDevice_Close_Call{Call: _e.mock.On("Close")}
+}
+
+func (_c *MockEvdevDevice_Close_Call) Run(run func()) *MockEvdevDevice_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockEvdevDevice_Close_Call) Return(_a0 error) *MockEvdevDevice_Close_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockEvdevDevice_Close_Call) RunAndReturn(run func() error) *MockEvdevDevice_Close_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Name provides a mock function with no fields
+func (_m *MockEvdevDevice) Name() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Name")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockEvdevDevice_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name'
+type MockEvdevDevice_Name_Call struct {
+	*mock.Call
+}
+
+// Name is a helper method to define mock.On call
+func (_e *MockEvdevDevice_Expecter) Name() *MockEvdevDevice_Name_Call {
+	return &MockEvdevDevice_Name_Call{Call: _e.mock.On("Name")}
+}
+
+func (_c *MockEvdevDevice_Name_Call) Run(run func()) *MockEvdevDevice_Name_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockEvdevDevice_Name_Call) Return(_a0 string, _a1 error) *MockEvdevDevice_Name_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockEvdevDevice_Name_Call) RunAndReturn(run func() (string, error)) *MockEvdevDevice_Name_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Path provides a mock function with no fields
+func (_m *MockEvdevDevice) Path() string {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Path")
+	}
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// MockEvdevDevice_Path_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Path'
+type MockEvdevDevice_Path_Call struct {
+	*mock.Call
+}
+
+// Path is a helper method to define mock.On call
+func (_e *MockEvdevDevice_Expecter) Path() *MockEvdevDevice_Path_Call {
+	return &MockEvdevDevice_Path_Call{Call: _e.mock.On("Path")}
+}
+
+func (_c *MockEvdevDevice_Path_Call) Run(run func()) *MockEvdevDevice_Path_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockEvdevDevice_Path_Call) Return(_a0 string) *MockEvdevDevice_Path_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockEvdevDevice_Path_Call) RunAndReturn(run func() string) *MockEvdevDevice_Path_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ReadOne provides a mock function with no fields
+func (_m *MockEvdevDevice) ReadOne() (*go_evdev.InputEvent, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for ReadOne")
+	}
+
+	var r0 *go_evdev.InputEvent
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (*go_evdev.InputEvent, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() *go_evdev.InputEvent); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*go_evdev.InputEvent)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockEvdevDevice_ReadOne_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadOne'
+type MockEvdevDevice_ReadOne_Call struct {
+	*mock.Call
+}
+
+// ReadOne is a helper method to define mock.On call
+func (_e *MockEvdevDevice_Expecter) ReadOne() *MockEvdevDevice_ReadOne_Call {
+	return &MockEvdevDevice_ReadOne_Call{Call: _e.mock.On("ReadOne")}
+}
+
+func (_c *MockEvdevDevice_ReadOne_Call) Run(run func()) *MockEvdevDevice_ReadOne_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockEvdevDevice_ReadOne_Call) Return(_a0 *go_evdev.InputEvent, _a1 error) *MockEvdevDevice_ReadOne_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockEvdevDevice_ReadOne_Call) RunAndReturn(run func() (*go_evdev.InputEvent, error)) *MockEvdevDevice_ReadOne_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// State provides a mock function with given fields: t
+func (_m *MockEvdevDevice) State(t go_evdev.EvType) (go_evdev.StateMap, error) {
+	ret := _m.Called(t)
+
+	if len(ret) == 0 {
+		panic("no return value specified for State")
+	}
+
+	var r0 go_evdev.StateMap
+	var r1 error
+	if rf, ok := ret.Get(0).(func(go_evdev.EvType) (go_evdev.StateMap, error)); ok {
+		return rf(t)
+	}
+	if rf, ok := ret.Get(0).(func(go_evdev.EvType) go_evdev.StateMap); ok {
+		r0 = rf(t)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(go_evdev.StateMap)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(go_evdev.EvType) error); ok {
+		r1 = rf(t)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockEvdevDevice_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State'
+type MockEvdevDevice_State_Call struct {
+	*mock.Call
+}
+
+// State is a helper method to define mock.On call
+//   - t go_evdev.EvType
+func (_e *MockEvdevDevice_Expecter) State(t interface{}) *MockEvdevDevice_State_Call {
+	return &MockEvdevDevice_State_Call{Call: _e.mock.On("State", t)}
+}
+
+func (_c *MockEvdevDevice_State_Call) Run(run func(t go_evdev.EvType)) *MockEvdevDevice_State_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(go_evdev.EvType))
+	})
+	return _c
+}
+
+func (_c *MockEvdevDevice_State_Call) Return(_a0 go_evdev.StateMap, _a1 error) *MockEvdevDevice_State_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockEvdevDevice_State_Call) RunAndReturn(run func(go_evdev.EvType) (go_evdev.StateMap, error)) *MockEvdevDevice_State_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockEvdevDevice creates a new instance of MockEvdevDevice. 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 NewMockEvdevDevice(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockEvdevDevice {
+	mock := &MockEvdevDevice{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/geolocation/mock_Client.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/geolocation/mock_Client.go
new file mode 100644
index 0000000..bf097cb
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/geolocation/mock_Client.go
@@ -0,0 +1,203 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package mocks_geolocation
+
+import (
+	geolocation "github.com/AvengeMedia/DankMaterialShell/core/internal/geolocation"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockClient is an autogenerated mock type for the Client type
+type MockClient struct {
+	mock.Mock
+}
+
+type MockClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockClient) EXPECT() *MockClient_Expecter {
+	return &MockClient_Expecter{mock: &_m.Mock}
+}
+
+// Close provides a mock function with no fields
+func (_m *MockClient) Close() {
+	_m.Called()
+}
+
+// MockClient_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type MockClient_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+func (_e *MockClient_Expecter) Close() *MockClient_Close_Call {
+	return &MockClient_Close_Call{Call: _e.mock.On("Close")}
+}
+
+func (_c *MockClient_Close_Call) Run(run func()) *MockClient_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockClient_Close_Call) Return() *MockClient_Close_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockClient_Close_Call) RunAndReturn(run func()) *MockClient_Close_Call {
+	_c.Run(run)
+	return _c
+}
+
+// GetLocation provides a mock function with no fields
+func (_m *MockClient) GetLocation() (geolocation.Location, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetLocation")
+	}
+
+	var r0 geolocation.Location
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (geolocation.Location, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() geolocation.Location); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(geolocation.Location)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockClient_GetLocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLocation'
+type MockClient_GetLocation_Call struct {
+	*mock.Call
+}
+
+// GetLocation is a helper method to define mock.On call
+func (_e *MockClient_Expecter) GetLocation() *MockClient_GetLocation_Call {
+	return &MockClient_GetLocation_Call{Call: _e.mock.On("GetLocation")}
+}
+
+func (_c *MockClient_GetLocation_Call) Run(run func()) *MockClient_GetLocation_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockClient_GetLocation_Call) Return(_a0 geolocation.Location, _a1 error) *MockClient_GetLocation_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockClient_GetLocation_Call) RunAndReturn(run func() (geolocation.Location, error)) *MockClient_GetLocation_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Subscribe provides a mock function with given fields: id
+func (_m *MockClient) Subscribe(id string) chan geolocation.Location {
+	ret := _m.Called(id)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Subscribe")
+	}
+
+	var r0 chan geolocation.Location
+	if rf, ok := ret.Get(0).(func(string) chan geolocation.Location); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(chan geolocation.Location)
+		}
+	}
+
+	return r0
+}
+
+// MockClient_Subscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Subscribe'
+type MockClient_Subscribe_Call struct {
+	*mock.Call
+}
+
+// Subscribe is a helper method to define mock.On call
+//   - id string
+func (_e *MockClient_Expecter) Subscribe(id interface{}) *MockClient_Subscribe_Call {
+	return &MockClient_Subscribe_Call{Call: _e.mock.On("Subscribe", id)}
+}
+
+func (_c *MockClient_Subscribe_Call) Run(run func(id string)) *MockClient_Subscribe_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockClient_Subscribe_Call) Return(_a0 chan geolocation.Location) *MockClient_Subscribe_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockClient_Subscribe_Call) RunAndReturn(run func(string) chan geolocation.Location) *MockClient_Subscribe_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Unsubscribe provides a mock function with given fields: id
+func (_m *MockClient) Unsubscribe(id string) {
+	_m.Called(id)
+}
+
+// MockClient_Unsubscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unsubscribe'
+type MockClient_Unsubscribe_Call struct {
+	*mock.Call
+}
+
+// Unsubscribe is a helper method to define mock.On call
+//   - id string
+func (_e *MockClient_Expecter) Unsubscribe(id interface{}) *MockClient_Unsubscribe_Call {
+	return &MockClient_Unsubscribe_Call{Call: _e.mock.On("Unsubscribe", id)}
+}
+
+func (_c *MockClient_Unsubscribe_Call) Run(run func(id string)) *MockClient_Unsubscribe_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockClient_Unsubscribe_Call) Return() *MockClient_Unsubscribe_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockClient_Unsubscribe_Call) RunAndReturn(run func(string)) *MockClient_Unsubscribe_Call {
+	_c.Run(run)
+	return _c
+}
+
+// NewMockClient creates a new instance of MockClient. 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 NewMockClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockClient {
+	mock := &MockClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_AccessPoint.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_AccessPoint.go
new file mode 100644
index 0000000..ae5124d
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_AccessPoint.go
@@ -0,0 +1,689 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package gonetworkmanager
+
+import (
+	gonetworkmanager "github.com/Wifx/gonetworkmanager/v2"
+	dbus "github.com/godbus/dbus/v5"
+
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockAccessPoint is an autogenerated mock type for the AccessPoint type
+type MockAccessPoint struct {
+	mock.Mock
+}
+
+type MockAccessPoint_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockAccessPoint) EXPECT() *MockAccessPoint_Expecter {
+	return &MockAccessPoint_Expecter{mock: &_m.Mock}
+}
+
+// GetPath provides a mock function with no fields
+func (_m *MockAccessPoint) GetPath() dbus.ObjectPath {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPath")
+	}
+
+	var r0 dbus.ObjectPath
+	if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(dbus.ObjectPath)
+	}
+
+	return r0
+}
+
+// MockAccessPoint_GetPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPath'
+type MockAccessPoint_GetPath_Call struct {
+	*mock.Call
+}
+
+// GetPath is a helper method to define mock.On call
+func (_e *MockAccessPoint_Expecter) GetPath() *MockAccessPoint_GetPath_Call {
+	return &MockAccessPoint_GetPath_Call{Call: _e.mock.On("GetPath")}
+}
+
+func (_c *MockAccessPoint_GetPath_Call) Run(run func()) *MockAccessPoint_GetPath_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPath_Call) Return(_a0 dbus.ObjectPath) *MockAccessPoint_GetPath_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPath_Call) RunAndReturn(run func() dbus.ObjectPath) *MockAccessPoint_GetPath_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyFlags provides a mock function with no fields
+func (_m *MockAccessPoint) GetPropertyFlags() (uint32, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyFlags")
+	}
+
+	var r0 uint32
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() uint32); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(uint32)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockAccessPoint_GetPropertyFlags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFlags'
+type MockAccessPoint_GetPropertyFlags_Call struct {
+	*mock.Call
+}
+
+// GetPropertyFlags is a helper method to define mock.On call
+func (_e *MockAccessPoint_Expecter) GetPropertyFlags() *MockAccessPoint_GetPropertyFlags_Call {
+	return &MockAccessPoint_GetPropertyFlags_Call{Call: _e.mock.On("GetPropertyFlags")}
+}
+
+func (_c *MockAccessPoint_GetPropertyFlags_Call) Run(run func()) *MockAccessPoint_GetPropertyFlags_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyFlags_Call) Return(_a0 uint32, _a1 error) *MockAccessPoint_GetPropertyFlags_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyFlags_Call) RunAndReturn(run func() (uint32, error)) *MockAccessPoint_GetPropertyFlags_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyFrequency provides a mock function with no fields
+func (_m *MockAccessPoint) GetPropertyFrequency() (uint32, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyFrequency")
+	}
+
+	var r0 uint32
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() uint32); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(uint32)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockAccessPoint_GetPropertyFrequency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFrequency'
+type MockAccessPoint_GetPropertyFrequency_Call struct {
+	*mock.Call
+}
+
+// GetPropertyFrequency is a helper method to define mock.On call
+func (_e *MockAccessPoint_Expecter) GetPropertyFrequency() *MockAccessPoint_GetPropertyFrequency_Call {
+	return &MockAccessPoint_GetPropertyFrequency_Call{Call: _e.mock.On("GetPropertyFrequency")}
+}
+
+func (_c *MockAccessPoint_GetPropertyFrequency_Call) Run(run func()) *MockAccessPoint_GetPropertyFrequency_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyFrequency_Call) Return(_a0 uint32, _a1 error) *MockAccessPoint_GetPropertyFrequency_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyFrequency_Call) RunAndReturn(run func() (uint32, error)) *MockAccessPoint_GetPropertyFrequency_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyHWAddress provides a mock function with no fields
+func (_m *MockAccessPoint) GetPropertyHWAddress() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyHWAddress")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockAccessPoint_GetPropertyHWAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyHWAddress'
+type MockAccessPoint_GetPropertyHWAddress_Call struct {
+	*mock.Call
+}
+
+// GetPropertyHWAddress is a helper method to define mock.On call
+func (_e *MockAccessPoint_Expecter) GetPropertyHWAddress() *MockAccessPoint_GetPropertyHWAddress_Call {
+	return &MockAccessPoint_GetPropertyHWAddress_Call{Call: _e.mock.On("GetPropertyHWAddress")}
+}
+
+func (_c *MockAccessPoint_GetPropertyHWAddress_Call) Run(run func()) *MockAccessPoint_GetPropertyHWAddress_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyHWAddress_Call) Return(_a0 string, _a1 error) *MockAccessPoint_GetPropertyHWAddress_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyHWAddress_Call) RunAndReturn(run func() (string, error)) *MockAccessPoint_GetPropertyHWAddress_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyLastSeen provides a mock function with no fields
+func (_m *MockAccessPoint) GetPropertyLastSeen() (int32, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyLastSeen")
+	}
+
+	var r0 int32
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (int32, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() int32); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(int32)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockAccessPoint_GetPropertyLastSeen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyLastSeen'
+type MockAccessPoint_GetPropertyLastSeen_Call struct {
+	*mock.Call
+}
+
+// GetPropertyLastSeen is a helper method to define mock.On call
+func (_e *MockAccessPoint_Expecter) GetPropertyLastSeen() *MockAccessPoint_GetPropertyLastSeen_Call {
+	return &MockAccessPoint_GetPropertyLastSeen_Call{Call: _e.mock.On("GetPropertyLastSeen")}
+}
+
+func (_c *MockAccessPoint_GetPropertyLastSeen_Call) Run(run func()) *MockAccessPoint_GetPropertyLastSeen_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyLastSeen_Call) Return(_a0 int32, _a1 error) *MockAccessPoint_GetPropertyLastSeen_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyLastSeen_Call) RunAndReturn(run func() (int32, error)) *MockAccessPoint_GetPropertyLastSeen_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyMaxBitrate provides a mock function with no fields
+func (_m *MockAccessPoint) GetPropertyMaxBitrate() (uint32, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyMaxBitrate")
+	}
+
+	var r0 uint32
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() uint32); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(uint32)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockAccessPoint_GetPropertyMaxBitrate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyMaxBitrate'
+type MockAccessPoint_GetPropertyMaxBitrate_Call struct {
+	*mock.Call
+}
+
+// GetPropertyMaxBitrate is a helper method to define mock.On call
+func (_e *MockAccessPoint_Expecter) GetPropertyMaxBitrate() *MockAccessPoint_GetPropertyMaxBitrate_Call {
+	return &MockAccessPoint_GetPropertyMaxBitrate_Call{Call: _e.mock.On("GetPropertyMaxBitrate")}
+}
+
+func (_c *MockAccessPoint_GetPropertyMaxBitrate_Call) Run(run func()) *MockAccessPoint_GetPropertyMaxBitrate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyMaxBitrate_Call) Return(_a0 uint32, _a1 error) *MockAccessPoint_GetPropertyMaxBitrate_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyMaxBitrate_Call) RunAndReturn(run func() (uint32, error)) *MockAccessPoint_GetPropertyMaxBitrate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyMode provides a mock function with no fields
+func (_m *MockAccessPoint) GetPropertyMode() (gonetworkmanager.Nm80211Mode, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyMode")
+	}
+
+	var r0 gonetworkmanager.Nm80211Mode
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.Nm80211Mode, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.Nm80211Mode); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(gonetworkmanager.Nm80211Mode)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockAccessPoint_GetPropertyMode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyMode'
+type MockAccessPoint_GetPropertyMode_Call struct {
+	*mock.Call
+}
+
+// GetPropertyMode is a helper method to define mock.On call
+func (_e *MockAccessPoint_Expecter) GetPropertyMode() *MockAccessPoint_GetPropertyMode_Call {
+	return &MockAccessPoint_GetPropertyMode_Call{Call: _e.mock.On("GetPropertyMode")}
+}
+
+func (_c *MockAccessPoint_GetPropertyMode_Call) Run(run func()) *MockAccessPoint_GetPropertyMode_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyMode_Call) Return(_a0 gonetworkmanager.Nm80211Mode, _a1 error) *MockAccessPoint_GetPropertyMode_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyMode_Call) RunAndReturn(run func() (gonetworkmanager.Nm80211Mode, error)) *MockAccessPoint_GetPropertyMode_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyRSNFlags provides a mock function with no fields
+func (_m *MockAccessPoint) GetPropertyRSNFlags() (uint32, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyRSNFlags")
+	}
+
+	var r0 uint32
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() uint32); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(uint32)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockAccessPoint_GetPropertyRSNFlags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyRSNFlags'
+type MockAccessPoint_GetPropertyRSNFlags_Call struct {
+	*mock.Call
+}
+
+// GetPropertyRSNFlags is a helper method to define mock.On call
+func (_e *MockAccessPoint_Expecter) GetPropertyRSNFlags() *MockAccessPoint_GetPropertyRSNFlags_Call {
+	return &MockAccessPoint_GetPropertyRSNFlags_Call{Call: _e.mock.On("GetPropertyRSNFlags")}
+}
+
+func (_c *MockAccessPoint_GetPropertyRSNFlags_Call) Run(run func()) *MockAccessPoint_GetPropertyRSNFlags_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyRSNFlags_Call) Return(_a0 uint32, _a1 error) *MockAccessPoint_GetPropertyRSNFlags_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyRSNFlags_Call) RunAndReturn(run func() (uint32, error)) *MockAccessPoint_GetPropertyRSNFlags_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertySSID provides a mock function with no fields
+func (_m *MockAccessPoint) GetPropertySSID() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertySSID")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockAccessPoint_GetPropertySSID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertySSID'
+type MockAccessPoint_GetPropertySSID_Call struct {
+	*mock.Call
+}
+
+// GetPropertySSID is a helper method to define mock.On call
+func (_e *MockAccessPoint_Expecter) GetPropertySSID() *MockAccessPoint_GetPropertySSID_Call {
+	return &MockAccessPoint_GetPropertySSID_Call{Call: _e.mock.On("GetPropertySSID")}
+}
+
+func (_c *MockAccessPoint_GetPropertySSID_Call) Run(run func()) *MockAccessPoint_GetPropertySSID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertySSID_Call) Return(_a0 string, _a1 error) *MockAccessPoint_GetPropertySSID_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertySSID_Call) RunAndReturn(run func() (string, error)) *MockAccessPoint_GetPropertySSID_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyStrength provides a mock function with no fields
+func (_m *MockAccessPoint) GetPropertyStrength() (uint8, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyStrength")
+	}
+
+	var r0 uint8
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (uint8, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() uint8); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(uint8)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockAccessPoint_GetPropertyStrength_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyStrength'
+type MockAccessPoint_GetPropertyStrength_Call struct {
+	*mock.Call
+}
+
+// GetPropertyStrength is a helper method to define mock.On call
+func (_e *MockAccessPoint_Expecter) GetPropertyStrength() *MockAccessPoint_GetPropertyStrength_Call {
+	return &MockAccessPoint_GetPropertyStrength_Call{Call: _e.mock.On("GetPropertyStrength")}
+}
+
+func (_c *MockAccessPoint_GetPropertyStrength_Call) Run(run func()) *MockAccessPoint_GetPropertyStrength_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyStrength_Call) Return(_a0 uint8, _a1 error) *MockAccessPoint_GetPropertyStrength_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyStrength_Call) RunAndReturn(run func() (uint8, error)) *MockAccessPoint_GetPropertyStrength_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyWPAFlags provides a mock function with no fields
+func (_m *MockAccessPoint) GetPropertyWPAFlags() (uint32, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyWPAFlags")
+	}
+
+	var r0 uint32
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() uint32); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(uint32)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockAccessPoint_GetPropertyWPAFlags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWPAFlags'
+type MockAccessPoint_GetPropertyWPAFlags_Call struct {
+	*mock.Call
+}
+
+// GetPropertyWPAFlags is a helper method to define mock.On call
+func (_e *MockAccessPoint_Expecter) GetPropertyWPAFlags() *MockAccessPoint_GetPropertyWPAFlags_Call {
+	return &MockAccessPoint_GetPropertyWPAFlags_Call{Call: _e.mock.On("GetPropertyWPAFlags")}
+}
+
+func (_c *MockAccessPoint_GetPropertyWPAFlags_Call) Run(run func()) *MockAccessPoint_GetPropertyWPAFlags_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyWPAFlags_Call) Return(_a0 uint32, _a1 error) *MockAccessPoint_GetPropertyWPAFlags_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockAccessPoint_GetPropertyWPAFlags_Call) RunAndReturn(run func() (uint32, error)) *MockAccessPoint_GetPropertyWPAFlags_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// MarshalJSON provides a mock function with no fields
+func (_m *MockAccessPoint) MarshalJSON() ([]byte, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarshalJSON")
+	}
+
+	var r0 []byte
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]byte, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []byte); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]byte)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockAccessPoint_MarshalJSON_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarshalJSON'
+type MockAccessPoint_MarshalJSON_Call struct {
+	*mock.Call
+}
+
+// MarshalJSON is a helper method to define mock.On call
+func (_e *MockAccessPoint_Expecter) MarshalJSON() *MockAccessPoint_MarshalJSON_Call {
+	return &MockAccessPoint_MarshalJSON_Call{Call: _e.mock.On("MarshalJSON")}
+}
+
+func (_c *MockAccessPoint_MarshalJSON_Call) Run(run func()) *MockAccessPoint_MarshalJSON_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockAccessPoint_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockAccessPoint_MarshalJSON_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockAccessPoint_MarshalJSON_Call) RunAndReturn(run func() ([]byte, error)) *MockAccessPoint_MarshalJSON_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockAccessPoint creates a new instance of MockAccessPoint. 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 NewMockAccessPoint(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockAccessPoint {
+	mock := &MockAccessPoint{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_ActiveConnection.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_ActiveConnection.go
new file mode 100644
index 0000000..a4e3344
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_ActiveConnection.go
@@ -0,0 +1,1025 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package gonetworkmanager
+
+import (
+	gonetworkmanager "github.com/Wifx/gonetworkmanager/v2"
+	dbus "github.com/godbus/dbus/v5"
+
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockActiveConnection is an autogenerated mock type for the ActiveConnection type
+type MockActiveConnection struct {
+	mock.Mock
+}
+
+type MockActiveConnection_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockActiveConnection) EXPECT() *MockActiveConnection_Expecter {
+	return &MockActiveConnection_Expecter{mock: &_m.Mock}
+}
+
+// GetPath provides a mock function with no fields
+func (_m *MockActiveConnection) GetPath() dbus.ObjectPath {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPath")
+	}
+
+	var r0 dbus.ObjectPath
+	if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(dbus.ObjectPath)
+	}
+
+	return r0
+}
+
+// MockActiveConnection_GetPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPath'
+type MockActiveConnection_GetPath_Call struct {
+	*mock.Call
+}
+
+// GetPath is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPath() *MockActiveConnection_GetPath_Call {
+	return &MockActiveConnection_GetPath_Call{Call: _e.mock.On("GetPath")}
+}
+
+func (_c *MockActiveConnection_GetPath_Call) Run(run func()) *MockActiveConnection_GetPath_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPath_Call) Return(_a0 dbus.ObjectPath) *MockActiveConnection_GetPath_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPath_Call) RunAndReturn(run func() dbus.ObjectPath) *MockActiveConnection_GetPath_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyConnection provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertyConnection() (gonetworkmanager.Connection, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyConnection")
+	}
+
+	var r0 gonetworkmanager.Connection
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.Connection, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.Connection); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.Connection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockActiveConnection_GetPropertyConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyConnection'
+type MockActiveConnection_GetPropertyConnection_Call struct {
+	*mock.Call
+}
+
+// GetPropertyConnection is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertyConnection() *MockActiveConnection_GetPropertyConnection_Call {
+	return &MockActiveConnection_GetPropertyConnection_Call{Call: _e.mock.On("GetPropertyConnection")}
+}
+
+func (_c *MockActiveConnection_GetPropertyConnection_Call) Run(run func()) *MockActiveConnection_GetPropertyConnection_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyConnection_Call) Return(_a0 gonetworkmanager.Connection, _a1 error) *MockActiveConnection_GetPropertyConnection_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyConnection_Call) RunAndReturn(run func() (gonetworkmanager.Connection, error)) *MockActiveConnection_GetPropertyConnection_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDHCP4Config provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertyDHCP4Config() (gonetworkmanager.DHCP4Config, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDHCP4Config")
+	}
+
+	var r0 gonetworkmanager.DHCP4Config
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.DHCP4Config, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.DHCP4Config); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.DHCP4Config)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockActiveConnection_GetPropertyDHCP4Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDHCP4Config'
+type MockActiveConnection_GetPropertyDHCP4Config_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDHCP4Config is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertyDHCP4Config() *MockActiveConnection_GetPropertyDHCP4Config_Call {
+	return &MockActiveConnection_GetPropertyDHCP4Config_Call{Call: _e.mock.On("GetPropertyDHCP4Config")}
+}
+
+func (_c *MockActiveConnection_GetPropertyDHCP4Config_Call) Run(run func()) *MockActiveConnection_GetPropertyDHCP4Config_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyDHCP4Config_Call) Return(_a0 gonetworkmanager.DHCP4Config, _a1 error) *MockActiveConnection_GetPropertyDHCP4Config_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyDHCP4Config_Call) RunAndReturn(run func() (gonetworkmanager.DHCP4Config, error)) *MockActiveConnection_GetPropertyDHCP4Config_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDHCP6Config provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertyDHCP6Config() (gonetworkmanager.DHCP6Config, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDHCP6Config")
+	}
+
+	var r0 gonetworkmanager.DHCP6Config
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.DHCP6Config, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.DHCP6Config); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.DHCP6Config)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockActiveConnection_GetPropertyDHCP6Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDHCP6Config'
+type MockActiveConnection_GetPropertyDHCP6Config_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDHCP6Config is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertyDHCP6Config() *MockActiveConnection_GetPropertyDHCP6Config_Call {
+	return &MockActiveConnection_GetPropertyDHCP6Config_Call{Call: _e.mock.On("GetPropertyDHCP6Config")}
+}
+
+func (_c *MockActiveConnection_GetPropertyDHCP6Config_Call) Run(run func()) *MockActiveConnection_GetPropertyDHCP6Config_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyDHCP6Config_Call) Return(_a0 gonetworkmanager.DHCP6Config, _a1 error) *MockActiveConnection_GetPropertyDHCP6Config_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyDHCP6Config_Call) RunAndReturn(run func() (gonetworkmanager.DHCP6Config, error)) *MockActiveConnection_GetPropertyDHCP6Config_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDefault provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertyDefault() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDefault")
+	}
+
+	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
+}
+
+// MockActiveConnection_GetPropertyDefault_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDefault'
+type MockActiveConnection_GetPropertyDefault_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDefault is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertyDefault() *MockActiveConnection_GetPropertyDefault_Call {
+	return &MockActiveConnection_GetPropertyDefault_Call{Call: _e.mock.On("GetPropertyDefault")}
+}
+
+func (_c *MockActiveConnection_GetPropertyDefault_Call) Run(run func()) *MockActiveConnection_GetPropertyDefault_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyDefault_Call) Return(_a0 bool, _a1 error) *MockActiveConnection_GetPropertyDefault_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyDefault_Call) RunAndReturn(run func() (bool, error)) *MockActiveConnection_GetPropertyDefault_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDefault6 provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertyDefault6() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDefault6")
+	}
+
+	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
+}
+
+// MockActiveConnection_GetPropertyDefault6_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDefault6'
+type MockActiveConnection_GetPropertyDefault6_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDefault6 is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertyDefault6() *MockActiveConnection_GetPropertyDefault6_Call {
+	return &MockActiveConnection_GetPropertyDefault6_Call{Call: _e.mock.On("GetPropertyDefault6")}
+}
+
+func (_c *MockActiveConnection_GetPropertyDefault6_Call) Run(run func()) *MockActiveConnection_GetPropertyDefault6_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyDefault6_Call) Return(_a0 bool, _a1 error) *MockActiveConnection_GetPropertyDefault6_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyDefault6_Call) RunAndReturn(run func() (bool, error)) *MockActiveConnection_GetPropertyDefault6_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDevices provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertyDevices() ([]gonetworkmanager.Device, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDevices")
+	}
+
+	var r0 []gonetworkmanager.Device
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.Device)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockActiveConnection_GetPropertyDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDevices'
+type MockActiveConnection_GetPropertyDevices_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDevices is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertyDevices() *MockActiveConnection_GetPropertyDevices_Call {
+	return &MockActiveConnection_GetPropertyDevices_Call{Call: _e.mock.On("GetPropertyDevices")}
+}
+
+func (_c *MockActiveConnection_GetPropertyDevices_Call) Run(run func()) *MockActiveConnection_GetPropertyDevices_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyDevices_Call) Return(_a0 []gonetworkmanager.Device, _a1 error) *MockActiveConnection_GetPropertyDevices_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyDevices_Call) RunAndReturn(run func() ([]gonetworkmanager.Device, error)) *MockActiveConnection_GetPropertyDevices_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyID provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertyID() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyID")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockActiveConnection_GetPropertyID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyID'
+type MockActiveConnection_GetPropertyID_Call struct {
+	*mock.Call
+}
+
+// GetPropertyID is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertyID() *MockActiveConnection_GetPropertyID_Call {
+	return &MockActiveConnection_GetPropertyID_Call{Call: _e.mock.On("GetPropertyID")}
+}
+
+func (_c *MockActiveConnection_GetPropertyID_Call) Run(run func()) *MockActiveConnection_GetPropertyID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyID_Call) Return(_a0 string, _a1 error) *MockActiveConnection_GetPropertyID_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyID_Call) RunAndReturn(run func() (string, error)) *MockActiveConnection_GetPropertyID_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyIP4Config provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertyIP4Config() (gonetworkmanager.IP4Config, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyIP4Config")
+	}
+
+	var r0 gonetworkmanager.IP4Config
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.IP4Config, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.IP4Config); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.IP4Config)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockActiveConnection_GetPropertyIP4Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIP4Config'
+type MockActiveConnection_GetPropertyIP4Config_Call struct {
+	*mock.Call
+}
+
+// GetPropertyIP4Config is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertyIP4Config() *MockActiveConnection_GetPropertyIP4Config_Call {
+	return &MockActiveConnection_GetPropertyIP4Config_Call{Call: _e.mock.On("GetPropertyIP4Config")}
+}
+
+func (_c *MockActiveConnection_GetPropertyIP4Config_Call) Run(run func()) *MockActiveConnection_GetPropertyIP4Config_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyIP4Config_Call) Return(_a0 gonetworkmanager.IP4Config, _a1 error) *MockActiveConnection_GetPropertyIP4Config_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyIP4Config_Call) RunAndReturn(run func() (gonetworkmanager.IP4Config, error)) *MockActiveConnection_GetPropertyIP4Config_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyIP6Config provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertyIP6Config() (gonetworkmanager.IP6Config, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyIP6Config")
+	}
+
+	var r0 gonetworkmanager.IP6Config
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.IP6Config, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.IP6Config); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.IP6Config)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockActiveConnection_GetPropertyIP6Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIP6Config'
+type MockActiveConnection_GetPropertyIP6Config_Call struct {
+	*mock.Call
+}
+
+// GetPropertyIP6Config is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertyIP6Config() *MockActiveConnection_GetPropertyIP6Config_Call {
+	return &MockActiveConnection_GetPropertyIP6Config_Call{Call: _e.mock.On("GetPropertyIP6Config")}
+}
+
+func (_c *MockActiveConnection_GetPropertyIP6Config_Call) Run(run func()) *MockActiveConnection_GetPropertyIP6Config_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyIP6Config_Call) Return(_a0 gonetworkmanager.IP6Config, _a1 error) *MockActiveConnection_GetPropertyIP6Config_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyIP6Config_Call) RunAndReturn(run func() (gonetworkmanager.IP6Config, error)) *MockActiveConnection_GetPropertyIP6Config_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyMaster provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertyMaster() (gonetworkmanager.Device, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyMaster")
+	}
+
+	var r0 gonetworkmanager.Device
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.Device, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.Device); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.Device)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockActiveConnection_GetPropertyMaster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyMaster'
+type MockActiveConnection_GetPropertyMaster_Call struct {
+	*mock.Call
+}
+
+// GetPropertyMaster is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertyMaster() *MockActiveConnection_GetPropertyMaster_Call {
+	return &MockActiveConnection_GetPropertyMaster_Call{Call: _e.mock.On("GetPropertyMaster")}
+}
+
+func (_c *MockActiveConnection_GetPropertyMaster_Call) Run(run func()) *MockActiveConnection_GetPropertyMaster_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyMaster_Call) Return(_a0 gonetworkmanager.Device, _a1 error) *MockActiveConnection_GetPropertyMaster_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyMaster_Call) RunAndReturn(run func() (gonetworkmanager.Device, error)) *MockActiveConnection_GetPropertyMaster_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertySpecificObject provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertySpecificObject() (gonetworkmanager.AccessPoint, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertySpecificObject")
+	}
+
+	var r0 gonetworkmanager.AccessPoint
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.AccessPoint, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.AccessPoint); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.AccessPoint)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockActiveConnection_GetPropertySpecificObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertySpecificObject'
+type MockActiveConnection_GetPropertySpecificObject_Call struct {
+	*mock.Call
+}
+
+// GetPropertySpecificObject is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertySpecificObject() *MockActiveConnection_GetPropertySpecificObject_Call {
+	return &MockActiveConnection_GetPropertySpecificObject_Call{Call: _e.mock.On("GetPropertySpecificObject")}
+}
+
+func (_c *MockActiveConnection_GetPropertySpecificObject_Call) Run(run func()) *MockActiveConnection_GetPropertySpecificObject_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertySpecificObject_Call) Return(_a0 gonetworkmanager.AccessPoint, _a1 error) *MockActiveConnection_GetPropertySpecificObject_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertySpecificObject_Call) RunAndReturn(run func() (gonetworkmanager.AccessPoint, error)) *MockActiveConnection_GetPropertySpecificObject_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyState provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertyState() (gonetworkmanager.NmActiveConnectionState, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyState")
+	}
+
+	var r0 gonetworkmanager.NmActiveConnectionState
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmActiveConnectionState, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.NmActiveConnectionState); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(gonetworkmanager.NmActiveConnectionState)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockActiveConnection_GetPropertyState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyState'
+type MockActiveConnection_GetPropertyState_Call struct {
+	*mock.Call
+}
+
+// GetPropertyState is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertyState() *MockActiveConnection_GetPropertyState_Call {
+	return &MockActiveConnection_GetPropertyState_Call{Call: _e.mock.On("GetPropertyState")}
+}
+
+func (_c *MockActiveConnection_GetPropertyState_Call) Run(run func()) *MockActiveConnection_GetPropertyState_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyState_Call) Return(_a0 gonetworkmanager.NmActiveConnectionState, _a1 error) *MockActiveConnection_GetPropertyState_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyState_Call) RunAndReturn(run func() (gonetworkmanager.NmActiveConnectionState, error)) *MockActiveConnection_GetPropertyState_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyStateFlags provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertyStateFlags() (uint32, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyStateFlags")
+	}
+
+	var r0 uint32
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() uint32); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(uint32)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockActiveConnection_GetPropertyStateFlags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyStateFlags'
+type MockActiveConnection_GetPropertyStateFlags_Call struct {
+	*mock.Call
+}
+
+// GetPropertyStateFlags is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertyStateFlags() *MockActiveConnection_GetPropertyStateFlags_Call {
+	return &MockActiveConnection_GetPropertyStateFlags_Call{Call: _e.mock.On("GetPropertyStateFlags")}
+}
+
+func (_c *MockActiveConnection_GetPropertyStateFlags_Call) Run(run func()) *MockActiveConnection_GetPropertyStateFlags_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyStateFlags_Call) Return(_a0 uint32, _a1 error) *MockActiveConnection_GetPropertyStateFlags_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyStateFlags_Call) RunAndReturn(run func() (uint32, error)) *MockActiveConnection_GetPropertyStateFlags_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyType provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertyType() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyType")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockActiveConnection_GetPropertyType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyType'
+type MockActiveConnection_GetPropertyType_Call struct {
+	*mock.Call
+}
+
+// GetPropertyType is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertyType() *MockActiveConnection_GetPropertyType_Call {
+	return &MockActiveConnection_GetPropertyType_Call{Call: _e.mock.On("GetPropertyType")}
+}
+
+func (_c *MockActiveConnection_GetPropertyType_Call) Run(run func()) *MockActiveConnection_GetPropertyType_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyType_Call) Return(_a0 string, _a1 error) *MockActiveConnection_GetPropertyType_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyType_Call) RunAndReturn(run func() (string, error)) *MockActiveConnection_GetPropertyType_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyUUID provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertyUUID() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyUUID")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockActiveConnection_GetPropertyUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyUUID'
+type MockActiveConnection_GetPropertyUUID_Call struct {
+	*mock.Call
+}
+
+// GetPropertyUUID is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertyUUID() *MockActiveConnection_GetPropertyUUID_Call {
+	return &MockActiveConnection_GetPropertyUUID_Call{Call: _e.mock.On("GetPropertyUUID")}
+}
+
+func (_c *MockActiveConnection_GetPropertyUUID_Call) Run(run func()) *MockActiveConnection_GetPropertyUUID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyUUID_Call) Return(_a0 string, _a1 error) *MockActiveConnection_GetPropertyUUID_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyUUID_Call) RunAndReturn(run func() (string, error)) *MockActiveConnection_GetPropertyUUID_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyVPN provides a mock function with no fields
+func (_m *MockActiveConnection) GetPropertyVPN() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyVPN")
+	}
+
+	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
+}
+
+// MockActiveConnection_GetPropertyVPN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyVPN'
+type MockActiveConnection_GetPropertyVPN_Call struct {
+	*mock.Call
+}
+
+// GetPropertyVPN is a helper method to define mock.On call
+func (_e *MockActiveConnection_Expecter) GetPropertyVPN() *MockActiveConnection_GetPropertyVPN_Call {
+	return &MockActiveConnection_GetPropertyVPN_Call{Call: _e.mock.On("GetPropertyVPN")}
+}
+
+func (_c *MockActiveConnection_GetPropertyVPN_Call) Run(run func()) *MockActiveConnection_GetPropertyVPN_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyVPN_Call) Return(_a0 bool, _a1 error) *MockActiveConnection_GetPropertyVPN_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockActiveConnection_GetPropertyVPN_Call) RunAndReturn(run func() (bool, error)) *MockActiveConnection_GetPropertyVPN_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SubscribeState provides a mock function with given fields: receiver, exit
+func (_m *MockActiveConnection) SubscribeState(receiver chan gonetworkmanager.StateChange, exit chan struct{}) error {
+	ret := _m.Called(receiver, exit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SubscribeState")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(chan gonetworkmanager.StateChange, chan struct{}) error); ok {
+		r0 = rf(receiver, exit)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockActiveConnection_SubscribeState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribeState'
+type MockActiveConnection_SubscribeState_Call struct {
+	*mock.Call
+}
+
+// SubscribeState is a helper method to define mock.On call
+//   - receiver chan gonetworkmanager.StateChange
+//   - exit chan struct{}
+func (_e *MockActiveConnection_Expecter) SubscribeState(receiver interface{}, exit interface{}) *MockActiveConnection_SubscribeState_Call {
+	return &MockActiveConnection_SubscribeState_Call{Call: _e.mock.On("SubscribeState", receiver, exit)}
+}
+
+func (_c *MockActiveConnection_SubscribeState_Call) Run(run func(receiver chan gonetworkmanager.StateChange, exit chan struct{})) *MockActiveConnection_SubscribeState_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(chan gonetworkmanager.StateChange), args[1].(chan struct{}))
+	})
+	return _c
+}
+
+func (_c *MockActiveConnection_SubscribeState_Call) Return(err error) *MockActiveConnection_SubscribeState_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockActiveConnection_SubscribeState_Call) RunAndReturn(run func(chan gonetworkmanager.StateChange, chan struct{}) error) *MockActiveConnection_SubscribeState_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockActiveConnection creates a new instance of MockActiveConnection. 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 NewMockActiveConnection(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockActiveConnection {
+	mock := &MockActiveConnection{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Connection.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Connection.go
new file mode 100644
index 0000000..84f59e1
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Connection.go
@@ -0,0 +1,646 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package gonetworkmanager
+
+import (
+	gonetworkmanager "github.com/Wifx/gonetworkmanager/v2"
+	dbus "github.com/godbus/dbus/v5"
+
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockConnection is an autogenerated mock type for the Connection type
+type MockConnection struct {
+	mock.Mock
+}
+
+type MockConnection_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockConnection) EXPECT() *MockConnection_Expecter {
+	return &MockConnection_Expecter{mock: &_m.Mock}
+}
+
+// ClearSecrets provides a mock function with no fields
+func (_m *MockConnection) ClearSecrets() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for ClearSecrets")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockConnection_ClearSecrets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearSecrets'
+type MockConnection_ClearSecrets_Call struct {
+	*mock.Call
+}
+
+// ClearSecrets is a helper method to define mock.On call
+func (_e *MockConnection_Expecter) ClearSecrets() *MockConnection_ClearSecrets_Call {
+	return &MockConnection_ClearSecrets_Call{Call: _e.mock.On("ClearSecrets")}
+}
+
+func (_c *MockConnection_ClearSecrets_Call) Run(run func()) *MockConnection_ClearSecrets_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockConnection_ClearSecrets_Call) Return(_a0 error) *MockConnection_ClearSecrets_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockConnection_ClearSecrets_Call) RunAndReturn(run func() error) *MockConnection_ClearSecrets_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Delete provides a mock function with no fields
+func (_m *MockConnection) Delete() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockConnection_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
+type MockConnection_Delete_Call struct {
+	*mock.Call
+}
+
+// Delete is a helper method to define mock.On call
+func (_e *MockConnection_Expecter) Delete() *MockConnection_Delete_Call {
+	return &MockConnection_Delete_Call{Call: _e.mock.On("Delete")}
+}
+
+func (_c *MockConnection_Delete_Call) Run(run func()) *MockConnection_Delete_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockConnection_Delete_Call) Return(_a0 error) *MockConnection_Delete_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockConnection_Delete_Call) RunAndReturn(run func() error) *MockConnection_Delete_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPath provides a mock function with no fields
+func (_m *MockConnection) GetPath() dbus.ObjectPath {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPath")
+	}
+
+	var r0 dbus.ObjectPath
+	if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(dbus.ObjectPath)
+	}
+
+	return r0
+}
+
+// MockConnection_GetPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPath'
+type MockConnection_GetPath_Call struct {
+	*mock.Call
+}
+
+// GetPath is a helper method to define mock.On call
+func (_e *MockConnection_Expecter) GetPath() *MockConnection_GetPath_Call {
+	return &MockConnection_GetPath_Call{Call: _e.mock.On("GetPath")}
+}
+
+func (_c *MockConnection_GetPath_Call) Run(run func()) *MockConnection_GetPath_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockConnection_GetPath_Call) Return(_a0 dbus.ObjectPath) *MockConnection_GetPath_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockConnection_GetPath_Call) RunAndReturn(run func() dbus.ObjectPath) *MockConnection_GetPath_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyFilename provides a mock function with no fields
+func (_m *MockConnection) GetPropertyFilename() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyFilename")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockConnection_GetPropertyFilename_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFilename'
+type MockConnection_GetPropertyFilename_Call struct {
+	*mock.Call
+}
+
+// GetPropertyFilename is a helper method to define mock.On call
+func (_e *MockConnection_Expecter) GetPropertyFilename() *MockConnection_GetPropertyFilename_Call {
+	return &MockConnection_GetPropertyFilename_Call{Call: _e.mock.On("GetPropertyFilename")}
+}
+
+func (_c *MockConnection_GetPropertyFilename_Call) Run(run func()) *MockConnection_GetPropertyFilename_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockConnection_GetPropertyFilename_Call) Return(_a0 string, _a1 error) *MockConnection_GetPropertyFilename_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockConnection_GetPropertyFilename_Call) RunAndReturn(run func() (string, error)) *MockConnection_GetPropertyFilename_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyFlags provides a mock function with no fields
+func (_m *MockConnection) GetPropertyFlags() (uint32, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyFlags")
+	}
+
+	var r0 uint32
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() uint32); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(uint32)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockConnection_GetPropertyFlags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFlags'
+type MockConnection_GetPropertyFlags_Call struct {
+	*mock.Call
+}
+
+// GetPropertyFlags is a helper method to define mock.On call
+func (_e *MockConnection_Expecter) GetPropertyFlags() *MockConnection_GetPropertyFlags_Call {
+	return &MockConnection_GetPropertyFlags_Call{Call: _e.mock.On("GetPropertyFlags")}
+}
+
+func (_c *MockConnection_GetPropertyFlags_Call) Run(run func()) *MockConnection_GetPropertyFlags_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockConnection_GetPropertyFlags_Call) Return(_a0 uint32, _a1 error) *MockConnection_GetPropertyFlags_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockConnection_GetPropertyFlags_Call) RunAndReturn(run func() (uint32, error)) *MockConnection_GetPropertyFlags_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyUnsaved provides a mock function with no fields
+func (_m *MockConnection) GetPropertyUnsaved() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyUnsaved")
+	}
+
+	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
+}
+
+// MockConnection_GetPropertyUnsaved_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyUnsaved'
+type MockConnection_GetPropertyUnsaved_Call struct {
+	*mock.Call
+}
+
+// GetPropertyUnsaved is a helper method to define mock.On call
+func (_e *MockConnection_Expecter) GetPropertyUnsaved() *MockConnection_GetPropertyUnsaved_Call {
+	return &MockConnection_GetPropertyUnsaved_Call{Call: _e.mock.On("GetPropertyUnsaved")}
+}
+
+func (_c *MockConnection_GetPropertyUnsaved_Call) Run(run func()) *MockConnection_GetPropertyUnsaved_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockConnection_GetPropertyUnsaved_Call) Return(_a0 bool, _a1 error) *MockConnection_GetPropertyUnsaved_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockConnection_GetPropertyUnsaved_Call) RunAndReturn(run func() (bool, error)) *MockConnection_GetPropertyUnsaved_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetSecrets provides a mock function with given fields: settingName
+func (_m *MockConnection) GetSecrets(settingName string) (gonetworkmanager.ConnectionSettings, error) {
+	ret := _m.Called(settingName)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSecrets")
+	}
+
+	var r0 gonetworkmanager.ConnectionSettings
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (gonetworkmanager.ConnectionSettings, error)); ok {
+		return rf(settingName)
+	}
+	if rf, ok := ret.Get(0).(func(string) gonetworkmanager.ConnectionSettings); ok {
+		r0 = rf(settingName)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.ConnectionSettings)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(settingName)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockConnection_GetSecrets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSecrets'
+type MockConnection_GetSecrets_Call struct {
+	*mock.Call
+}
+
+// GetSecrets is a helper method to define mock.On call
+//   - settingName string
+func (_e *MockConnection_Expecter) GetSecrets(settingName interface{}) *MockConnection_GetSecrets_Call {
+	return &MockConnection_GetSecrets_Call{Call: _e.mock.On("GetSecrets", settingName)}
+}
+
+func (_c *MockConnection_GetSecrets_Call) Run(run func(settingName string)) *MockConnection_GetSecrets_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockConnection_GetSecrets_Call) Return(_a0 gonetworkmanager.ConnectionSettings, _a1 error) *MockConnection_GetSecrets_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockConnection_GetSecrets_Call) RunAndReturn(run func(string) (gonetworkmanager.ConnectionSettings, error)) *MockConnection_GetSecrets_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetSettings provides a mock function with no fields
+func (_m *MockConnection) GetSettings() (gonetworkmanager.ConnectionSettings, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSettings")
+	}
+
+	var r0 gonetworkmanager.ConnectionSettings
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.ConnectionSettings, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.ConnectionSettings); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.ConnectionSettings)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockConnection_GetSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSettings'
+type MockConnection_GetSettings_Call struct {
+	*mock.Call
+}
+
+// GetSettings is a helper method to define mock.On call
+func (_e *MockConnection_Expecter) GetSettings() *MockConnection_GetSettings_Call {
+	return &MockConnection_GetSettings_Call{Call: _e.mock.On("GetSettings")}
+}
+
+func (_c *MockConnection_GetSettings_Call) Run(run func()) *MockConnection_GetSettings_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockConnection_GetSettings_Call) Return(_a0 gonetworkmanager.ConnectionSettings, _a1 error) *MockConnection_GetSettings_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockConnection_GetSettings_Call) RunAndReturn(run func() (gonetworkmanager.ConnectionSettings, error)) *MockConnection_GetSettings_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// MarshalJSON provides a mock function with no fields
+func (_m *MockConnection) MarshalJSON() ([]byte, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarshalJSON")
+	}
+
+	var r0 []byte
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]byte, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []byte); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]byte)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockConnection_MarshalJSON_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarshalJSON'
+type MockConnection_MarshalJSON_Call struct {
+	*mock.Call
+}
+
+// MarshalJSON is a helper method to define mock.On call
+func (_e *MockConnection_Expecter) MarshalJSON() *MockConnection_MarshalJSON_Call {
+	return &MockConnection_MarshalJSON_Call{Call: _e.mock.On("MarshalJSON")}
+}
+
+func (_c *MockConnection_MarshalJSON_Call) Run(run func()) *MockConnection_MarshalJSON_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockConnection_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockConnection_MarshalJSON_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockConnection_MarshalJSON_Call) RunAndReturn(run func() ([]byte, error)) *MockConnection_MarshalJSON_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Save provides a mock function with no fields
+func (_m *MockConnection) Save() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Save")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockConnection_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save'
+type MockConnection_Save_Call struct {
+	*mock.Call
+}
+
+// Save is a helper method to define mock.On call
+func (_e *MockConnection_Expecter) Save() *MockConnection_Save_Call {
+	return &MockConnection_Save_Call{Call: _e.mock.On("Save")}
+}
+
+func (_c *MockConnection_Save_Call) Run(run func()) *MockConnection_Save_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockConnection_Save_Call) Return(_a0 error) *MockConnection_Save_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockConnection_Save_Call) RunAndReturn(run func() error) *MockConnection_Save_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Update provides a mock function with given fields: settings
+func (_m *MockConnection) Update(settings gonetworkmanager.ConnectionSettings) error {
+	ret := _m.Called(settings)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Update")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) error); ok {
+		r0 = rf(settings)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockConnection_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'
+type MockConnection_Update_Call struct {
+	*mock.Call
+}
+
+// Update is a helper method to define mock.On call
+//   - settings gonetworkmanager.ConnectionSettings
+func (_e *MockConnection_Expecter) Update(settings interface{}) *MockConnection_Update_Call {
+	return &MockConnection_Update_Call{Call: _e.mock.On("Update", settings)}
+}
+
+func (_c *MockConnection_Update_Call) Run(run func(settings gonetworkmanager.ConnectionSettings)) *MockConnection_Update_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(gonetworkmanager.ConnectionSettings))
+	})
+	return _c
+}
+
+func (_c *MockConnection_Update_Call) Return(_a0 error) *MockConnection_Update_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockConnection_Update_Call) RunAndReturn(run func(gonetworkmanager.ConnectionSettings) error) *MockConnection_Update_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// UpdateUnsaved provides a mock function with given fields: settings
+func (_m *MockConnection) UpdateUnsaved(settings gonetworkmanager.ConnectionSettings) error {
+	ret := _m.Called(settings)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateUnsaved")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) error); ok {
+		r0 = rf(settings)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockConnection_UpdateUnsaved_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUnsaved'
+type MockConnection_UpdateUnsaved_Call struct {
+	*mock.Call
+}
+
+// UpdateUnsaved is a helper method to define mock.On call
+//   - settings gonetworkmanager.ConnectionSettings
+func (_e *MockConnection_Expecter) UpdateUnsaved(settings interface{}) *MockConnection_UpdateUnsaved_Call {
+	return &MockConnection_UpdateUnsaved_Call{Call: _e.mock.On("UpdateUnsaved", settings)}
+}
+
+func (_c *MockConnection_UpdateUnsaved_Call) Run(run func(settings gonetworkmanager.ConnectionSettings)) *MockConnection_UpdateUnsaved_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(gonetworkmanager.ConnectionSettings))
+	})
+	return _c
+}
+
+func (_c *MockConnection_UpdateUnsaved_Call) Return(_a0 error) *MockConnection_UpdateUnsaved_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockConnection_UpdateUnsaved_Call) RunAndReturn(run func(gonetworkmanager.ConnectionSettings) error) *MockConnection_UpdateUnsaved_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockConnection creates a new instance of MockConnection. 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 NewMockConnection(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockConnection {
+	mock := &MockConnection{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Device.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Device.go
new file mode 100644
index 0000000..b2fc0b5
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Device.go
@@ -0,0 +1,1638 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package gonetworkmanager
+
+import (
+	gonetworkmanager "github.com/Wifx/gonetworkmanager/v2"
+	dbus "github.com/godbus/dbus/v5"
+
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockDevice is an autogenerated mock type for the Device type
+type MockDevice struct {
+	mock.Mock
+}
+
+type MockDevice_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockDevice) EXPECT() *MockDevice_Expecter {
+	return &MockDevice_Expecter{mock: &_m.Mock}
+}
+
+// Delete provides a mock function with no fields
+func (_m *MockDevice) Delete() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockDevice_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
+type MockDevice_Delete_Call struct {
+	*mock.Call
+}
+
+// Delete is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) Delete() *MockDevice_Delete_Call {
+	return &MockDevice_Delete_Call{Call: _e.mock.On("Delete")}
+}
+
+func (_c *MockDevice_Delete_Call) Run(run func()) *MockDevice_Delete_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_Delete_Call) Return(_a0 error) *MockDevice_Delete_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockDevice_Delete_Call) RunAndReturn(run func() error) *MockDevice_Delete_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Disconnect provides a mock function with no fields
+func (_m *MockDevice) Disconnect() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Disconnect")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockDevice_Disconnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Disconnect'
+type MockDevice_Disconnect_Call struct {
+	*mock.Call
+}
+
+// Disconnect is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) Disconnect() *MockDevice_Disconnect_Call {
+	return &MockDevice_Disconnect_Call{Call: _e.mock.On("Disconnect")}
+}
+
+func (_c *MockDevice_Disconnect_Call) Run(run func()) *MockDevice_Disconnect_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_Disconnect_Call) Return(_a0 error) *MockDevice_Disconnect_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockDevice_Disconnect_Call) RunAndReturn(run func() error) *MockDevice_Disconnect_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPath provides a mock function with no fields
+func (_m *MockDevice) GetPath() dbus.ObjectPath {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPath")
+	}
+
+	var r0 dbus.ObjectPath
+	if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(dbus.ObjectPath)
+	}
+
+	return r0
+}
+
+// MockDevice_GetPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPath'
+type MockDevice_GetPath_Call struct {
+	*mock.Call
+}
+
+// GetPath is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPath() *MockDevice_GetPath_Call {
+	return &MockDevice_GetPath_Call{Call: _e.mock.On("GetPath")}
+}
+
+func (_c *MockDevice_GetPath_Call) Run(run func()) *MockDevice_GetPath_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPath_Call) Return(_a0 dbus.ObjectPath) *MockDevice_GetPath_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockDevice_GetPath_Call) RunAndReturn(run func() dbus.ObjectPath) *MockDevice_GetPath_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyActiveConnection provides a mock function with no fields
+func (_m *MockDevice) GetPropertyActiveConnection() (gonetworkmanager.ActiveConnection, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyActiveConnection")
+	}
+
+	var r0 gonetworkmanager.ActiveConnection
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.ActiveConnection, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.ActiveConnection); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.ActiveConnection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyActiveConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyActiveConnection'
+type MockDevice_GetPropertyActiveConnection_Call struct {
+	*mock.Call
+}
+
+// GetPropertyActiveConnection is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyActiveConnection() *MockDevice_GetPropertyActiveConnection_Call {
+	return &MockDevice_GetPropertyActiveConnection_Call{Call: _e.mock.On("GetPropertyActiveConnection")}
+}
+
+func (_c *MockDevice_GetPropertyActiveConnection_Call) Run(run func()) *MockDevice_GetPropertyActiveConnection_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyActiveConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockDevice_GetPropertyActiveConnection_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyActiveConnection_Call) RunAndReturn(run func() (gonetworkmanager.ActiveConnection, error)) *MockDevice_GetPropertyActiveConnection_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyAutoConnect provides a mock function with no fields
+func (_m *MockDevice) GetPropertyAutoConnect() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyAutoConnect")
+	}
+
+	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
+}
+
+// MockDevice_GetPropertyAutoConnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAutoConnect'
+type MockDevice_GetPropertyAutoConnect_Call struct {
+	*mock.Call
+}
+
+// GetPropertyAutoConnect is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyAutoConnect() *MockDevice_GetPropertyAutoConnect_Call {
+	return &MockDevice_GetPropertyAutoConnect_Call{Call: _e.mock.On("GetPropertyAutoConnect")}
+}
+
+func (_c *MockDevice_GetPropertyAutoConnect_Call) Run(run func()) *MockDevice_GetPropertyAutoConnect_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyAutoConnect_Call) Return(_a0 bool, _a1 error) *MockDevice_GetPropertyAutoConnect_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyAutoConnect_Call) RunAndReturn(run func() (bool, error)) *MockDevice_GetPropertyAutoConnect_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyAvailableConnections provides a mock function with no fields
+func (_m *MockDevice) GetPropertyAvailableConnections() ([]gonetworkmanager.Connection, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyAvailableConnections")
+	}
+
+	var r0 []gonetworkmanager.Connection
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Connection, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.Connection); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.Connection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyAvailableConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAvailableConnections'
+type MockDevice_GetPropertyAvailableConnections_Call struct {
+	*mock.Call
+}
+
+// GetPropertyAvailableConnections is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyAvailableConnections() *MockDevice_GetPropertyAvailableConnections_Call {
+	return &MockDevice_GetPropertyAvailableConnections_Call{Call: _e.mock.On("GetPropertyAvailableConnections")}
+}
+
+func (_c *MockDevice_GetPropertyAvailableConnections_Call) Run(run func()) *MockDevice_GetPropertyAvailableConnections_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyAvailableConnections_Call) Return(_a0 []gonetworkmanager.Connection, _a1 error) *MockDevice_GetPropertyAvailableConnections_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyAvailableConnections_Call) RunAndReturn(run func() ([]gonetworkmanager.Connection, error)) *MockDevice_GetPropertyAvailableConnections_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDHCP4Config provides a mock function with no fields
+func (_m *MockDevice) GetPropertyDHCP4Config() (gonetworkmanager.DHCP4Config, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDHCP4Config")
+	}
+
+	var r0 gonetworkmanager.DHCP4Config
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.DHCP4Config, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.DHCP4Config); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.DHCP4Config)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyDHCP4Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDHCP4Config'
+type MockDevice_GetPropertyDHCP4Config_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDHCP4Config is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyDHCP4Config() *MockDevice_GetPropertyDHCP4Config_Call {
+	return &MockDevice_GetPropertyDHCP4Config_Call{Call: _e.mock.On("GetPropertyDHCP4Config")}
+}
+
+func (_c *MockDevice_GetPropertyDHCP4Config_Call) Run(run func()) *MockDevice_GetPropertyDHCP4Config_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyDHCP4Config_Call) Return(_a0 gonetworkmanager.DHCP4Config, _a1 error) *MockDevice_GetPropertyDHCP4Config_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyDHCP4Config_Call) RunAndReturn(run func() (gonetworkmanager.DHCP4Config, error)) *MockDevice_GetPropertyDHCP4Config_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDHCP6Config provides a mock function with no fields
+func (_m *MockDevice) GetPropertyDHCP6Config() (gonetworkmanager.DHCP6Config, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDHCP6Config")
+	}
+
+	var r0 gonetworkmanager.DHCP6Config
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.DHCP6Config, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.DHCP6Config); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.DHCP6Config)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyDHCP6Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDHCP6Config'
+type MockDevice_GetPropertyDHCP6Config_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDHCP6Config is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyDHCP6Config() *MockDevice_GetPropertyDHCP6Config_Call {
+	return &MockDevice_GetPropertyDHCP6Config_Call{Call: _e.mock.On("GetPropertyDHCP6Config")}
+}
+
+func (_c *MockDevice_GetPropertyDHCP6Config_Call) Run(run func()) *MockDevice_GetPropertyDHCP6Config_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyDHCP6Config_Call) Return(_a0 gonetworkmanager.DHCP6Config, _a1 error) *MockDevice_GetPropertyDHCP6Config_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyDHCP6Config_Call) RunAndReturn(run func() (gonetworkmanager.DHCP6Config, error)) *MockDevice_GetPropertyDHCP6Config_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDeviceType provides a mock function with no fields
+func (_m *MockDevice) GetPropertyDeviceType() (gonetworkmanager.NmDeviceType, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDeviceType")
+	}
+
+	var r0 gonetworkmanager.NmDeviceType
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmDeviceType, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.NmDeviceType); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(gonetworkmanager.NmDeviceType)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyDeviceType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDeviceType'
+type MockDevice_GetPropertyDeviceType_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDeviceType is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyDeviceType() *MockDevice_GetPropertyDeviceType_Call {
+	return &MockDevice_GetPropertyDeviceType_Call{Call: _e.mock.On("GetPropertyDeviceType")}
+}
+
+func (_c *MockDevice_GetPropertyDeviceType_Call) Run(run func()) *MockDevice_GetPropertyDeviceType_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyDeviceType_Call) Return(_a0 gonetworkmanager.NmDeviceType, _a1 error) *MockDevice_GetPropertyDeviceType_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyDeviceType_Call) RunAndReturn(run func() (gonetworkmanager.NmDeviceType, error)) *MockDevice_GetPropertyDeviceType_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDriver provides a mock function with no fields
+func (_m *MockDevice) GetPropertyDriver() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDriver")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyDriver_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDriver'
+type MockDevice_GetPropertyDriver_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDriver is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyDriver() *MockDevice_GetPropertyDriver_Call {
+	return &MockDevice_GetPropertyDriver_Call{Call: _e.mock.On("GetPropertyDriver")}
+}
+
+func (_c *MockDevice_GetPropertyDriver_Call) Run(run func()) *MockDevice_GetPropertyDriver_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyDriver_Call) Return(_a0 string, _a1 error) *MockDevice_GetPropertyDriver_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyDriver_Call) RunAndReturn(run func() (string, error)) *MockDevice_GetPropertyDriver_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDriverVersion provides a mock function with no fields
+func (_m *MockDevice) GetPropertyDriverVersion() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDriverVersion")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyDriverVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDriverVersion'
+type MockDevice_GetPropertyDriverVersion_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDriverVersion is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyDriverVersion() *MockDevice_GetPropertyDriverVersion_Call {
+	return &MockDevice_GetPropertyDriverVersion_Call{Call: _e.mock.On("GetPropertyDriverVersion")}
+}
+
+func (_c *MockDevice_GetPropertyDriverVersion_Call) Run(run func()) *MockDevice_GetPropertyDriverVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyDriverVersion_Call) Return(_a0 string, _a1 error) *MockDevice_GetPropertyDriverVersion_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyDriverVersion_Call) RunAndReturn(run func() (string, error)) *MockDevice_GetPropertyDriverVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyFirmwareMissing provides a mock function with no fields
+func (_m *MockDevice) GetPropertyFirmwareMissing() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyFirmwareMissing")
+	}
+
+	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
+}
+
+// MockDevice_GetPropertyFirmwareMissing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFirmwareMissing'
+type MockDevice_GetPropertyFirmwareMissing_Call struct {
+	*mock.Call
+}
+
+// GetPropertyFirmwareMissing is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyFirmwareMissing() *MockDevice_GetPropertyFirmwareMissing_Call {
+	return &MockDevice_GetPropertyFirmwareMissing_Call{Call: _e.mock.On("GetPropertyFirmwareMissing")}
+}
+
+func (_c *MockDevice_GetPropertyFirmwareMissing_Call) Run(run func()) *MockDevice_GetPropertyFirmwareMissing_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyFirmwareMissing_Call) Return(_a0 bool, _a1 error) *MockDevice_GetPropertyFirmwareMissing_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyFirmwareMissing_Call) RunAndReturn(run func() (bool, error)) *MockDevice_GetPropertyFirmwareMissing_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyFirmwareVersion provides a mock function with no fields
+func (_m *MockDevice) GetPropertyFirmwareVersion() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyFirmwareVersion")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyFirmwareVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFirmwareVersion'
+type MockDevice_GetPropertyFirmwareVersion_Call struct {
+	*mock.Call
+}
+
+// GetPropertyFirmwareVersion is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyFirmwareVersion() *MockDevice_GetPropertyFirmwareVersion_Call {
+	return &MockDevice_GetPropertyFirmwareVersion_Call{Call: _e.mock.On("GetPropertyFirmwareVersion")}
+}
+
+func (_c *MockDevice_GetPropertyFirmwareVersion_Call) Run(run func()) *MockDevice_GetPropertyFirmwareVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyFirmwareVersion_Call) Return(_a0 string, _a1 error) *MockDevice_GetPropertyFirmwareVersion_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyFirmwareVersion_Call) RunAndReturn(run func() (string, error)) *MockDevice_GetPropertyFirmwareVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyIP4Config provides a mock function with no fields
+func (_m *MockDevice) GetPropertyIP4Config() (gonetworkmanager.IP4Config, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyIP4Config")
+	}
+
+	var r0 gonetworkmanager.IP4Config
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.IP4Config, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.IP4Config); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.IP4Config)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyIP4Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIP4Config'
+type MockDevice_GetPropertyIP4Config_Call struct {
+	*mock.Call
+}
+
+// GetPropertyIP4Config is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyIP4Config() *MockDevice_GetPropertyIP4Config_Call {
+	return &MockDevice_GetPropertyIP4Config_Call{Call: _e.mock.On("GetPropertyIP4Config")}
+}
+
+func (_c *MockDevice_GetPropertyIP4Config_Call) Run(run func()) *MockDevice_GetPropertyIP4Config_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyIP4Config_Call) Return(_a0 gonetworkmanager.IP4Config, _a1 error) *MockDevice_GetPropertyIP4Config_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyIP4Config_Call) RunAndReturn(run func() (gonetworkmanager.IP4Config, error)) *MockDevice_GetPropertyIP4Config_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyIP6Config provides a mock function with no fields
+func (_m *MockDevice) GetPropertyIP6Config() (gonetworkmanager.IP6Config, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyIP6Config")
+	}
+
+	var r0 gonetworkmanager.IP6Config
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.IP6Config, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.IP6Config); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.IP6Config)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyIP6Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIP6Config'
+type MockDevice_GetPropertyIP6Config_Call struct {
+	*mock.Call
+}
+
+// GetPropertyIP6Config is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyIP6Config() *MockDevice_GetPropertyIP6Config_Call {
+	return &MockDevice_GetPropertyIP6Config_Call{Call: _e.mock.On("GetPropertyIP6Config")}
+}
+
+func (_c *MockDevice_GetPropertyIP6Config_Call) Run(run func()) *MockDevice_GetPropertyIP6Config_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyIP6Config_Call) Return(_a0 gonetworkmanager.IP6Config, _a1 error) *MockDevice_GetPropertyIP6Config_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyIP6Config_Call) RunAndReturn(run func() (gonetworkmanager.IP6Config, error)) *MockDevice_GetPropertyIP6Config_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyInterface provides a mock function with no fields
+func (_m *MockDevice) GetPropertyInterface() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyInterface")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyInterface'
+type MockDevice_GetPropertyInterface_Call struct {
+	*mock.Call
+}
+
+// GetPropertyInterface is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyInterface() *MockDevice_GetPropertyInterface_Call {
+	return &MockDevice_GetPropertyInterface_Call{Call: _e.mock.On("GetPropertyInterface")}
+}
+
+func (_c *MockDevice_GetPropertyInterface_Call) Run(run func()) *MockDevice_GetPropertyInterface_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyInterface_Call) Return(_a0 string, _a1 error) *MockDevice_GetPropertyInterface_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyInterface_Call) RunAndReturn(run func() (string, error)) *MockDevice_GetPropertyInterface_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyIp4Connectivity provides a mock function with no fields
+func (_m *MockDevice) GetPropertyIp4Connectivity() (gonetworkmanager.NmConnectivity, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyIp4Connectivity")
+	}
+
+	var r0 gonetworkmanager.NmConnectivity
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmConnectivity, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.NmConnectivity); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(gonetworkmanager.NmConnectivity)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyIp4Connectivity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIp4Connectivity'
+type MockDevice_GetPropertyIp4Connectivity_Call struct {
+	*mock.Call
+}
+
+// GetPropertyIp4Connectivity is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyIp4Connectivity() *MockDevice_GetPropertyIp4Connectivity_Call {
+	return &MockDevice_GetPropertyIp4Connectivity_Call{Call: _e.mock.On("GetPropertyIp4Connectivity")}
+}
+
+func (_c *MockDevice_GetPropertyIp4Connectivity_Call) Run(run func()) *MockDevice_GetPropertyIp4Connectivity_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyIp4Connectivity_Call) Return(_a0 gonetworkmanager.NmConnectivity, _a1 error) *MockDevice_GetPropertyIp4Connectivity_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyIp4Connectivity_Call) RunAndReturn(run func() (gonetworkmanager.NmConnectivity, error)) *MockDevice_GetPropertyIp4Connectivity_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyIpInterface provides a mock function with no fields
+func (_m *MockDevice) GetPropertyIpInterface() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyIpInterface")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyIpInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIpInterface'
+type MockDevice_GetPropertyIpInterface_Call struct {
+	*mock.Call
+}
+
+// GetPropertyIpInterface is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyIpInterface() *MockDevice_GetPropertyIpInterface_Call {
+	return &MockDevice_GetPropertyIpInterface_Call{Call: _e.mock.On("GetPropertyIpInterface")}
+}
+
+func (_c *MockDevice_GetPropertyIpInterface_Call) Run(run func()) *MockDevice_GetPropertyIpInterface_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyIpInterface_Call) Return(_a0 string, _a1 error) *MockDevice_GetPropertyIpInterface_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyIpInterface_Call) RunAndReturn(run func() (string, error)) *MockDevice_GetPropertyIpInterface_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyManaged provides a mock function with no fields
+func (_m *MockDevice) GetPropertyManaged() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyManaged")
+	}
+
+	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
+}
+
+// MockDevice_GetPropertyManaged_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyManaged'
+type MockDevice_GetPropertyManaged_Call struct {
+	*mock.Call
+}
+
+// GetPropertyManaged is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyManaged() *MockDevice_GetPropertyManaged_Call {
+	return &MockDevice_GetPropertyManaged_Call{Call: _e.mock.On("GetPropertyManaged")}
+}
+
+func (_c *MockDevice_GetPropertyManaged_Call) Run(run func()) *MockDevice_GetPropertyManaged_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyManaged_Call) Return(_a0 bool, _a1 error) *MockDevice_GetPropertyManaged_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyManaged_Call) RunAndReturn(run func() (bool, error)) *MockDevice_GetPropertyManaged_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyMtu provides a mock function with no fields
+func (_m *MockDevice) GetPropertyMtu() (uint32, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyMtu")
+	}
+
+	var r0 uint32
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() uint32); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(uint32)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyMtu_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyMtu'
+type MockDevice_GetPropertyMtu_Call struct {
+	*mock.Call
+}
+
+// GetPropertyMtu is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyMtu() *MockDevice_GetPropertyMtu_Call {
+	return &MockDevice_GetPropertyMtu_Call{Call: _e.mock.On("GetPropertyMtu")}
+}
+
+func (_c *MockDevice_GetPropertyMtu_Call) Run(run func()) *MockDevice_GetPropertyMtu_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyMtu_Call) Return(_a0 uint32, _a1 error) *MockDevice_GetPropertyMtu_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyMtu_Call) RunAndReturn(run func() (uint32, error)) *MockDevice_GetPropertyMtu_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyNmPluginMissing provides a mock function with no fields
+func (_m *MockDevice) GetPropertyNmPluginMissing() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyNmPluginMissing")
+	}
+
+	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
+}
+
+// MockDevice_GetPropertyNmPluginMissing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyNmPluginMissing'
+type MockDevice_GetPropertyNmPluginMissing_Call struct {
+	*mock.Call
+}
+
+// GetPropertyNmPluginMissing is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyNmPluginMissing() *MockDevice_GetPropertyNmPluginMissing_Call {
+	return &MockDevice_GetPropertyNmPluginMissing_Call{Call: _e.mock.On("GetPropertyNmPluginMissing")}
+}
+
+func (_c *MockDevice_GetPropertyNmPluginMissing_Call) Run(run func()) *MockDevice_GetPropertyNmPluginMissing_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyNmPluginMissing_Call) Return(_a0 bool, _a1 error) *MockDevice_GetPropertyNmPluginMissing_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyNmPluginMissing_Call) RunAndReturn(run func() (bool, error)) *MockDevice_GetPropertyNmPluginMissing_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyPhysicalPortId provides a mock function with no fields
+func (_m *MockDevice) GetPropertyPhysicalPortId() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyPhysicalPortId")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyPhysicalPortId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyPhysicalPortId'
+type MockDevice_GetPropertyPhysicalPortId_Call struct {
+	*mock.Call
+}
+
+// GetPropertyPhysicalPortId is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyPhysicalPortId() *MockDevice_GetPropertyPhysicalPortId_Call {
+	return &MockDevice_GetPropertyPhysicalPortId_Call{Call: _e.mock.On("GetPropertyPhysicalPortId")}
+}
+
+func (_c *MockDevice_GetPropertyPhysicalPortId_Call) Run(run func()) *MockDevice_GetPropertyPhysicalPortId_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyPhysicalPortId_Call) Return(_a0 string, _a1 error) *MockDevice_GetPropertyPhysicalPortId_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyPhysicalPortId_Call) RunAndReturn(run func() (string, error)) *MockDevice_GetPropertyPhysicalPortId_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyReal provides a mock function with no fields
+func (_m *MockDevice) GetPropertyReal() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyReal")
+	}
+
+	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
+}
+
+// MockDevice_GetPropertyReal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyReal'
+type MockDevice_GetPropertyReal_Call struct {
+	*mock.Call
+}
+
+// GetPropertyReal is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyReal() *MockDevice_GetPropertyReal_Call {
+	return &MockDevice_GetPropertyReal_Call{Call: _e.mock.On("GetPropertyReal")}
+}
+
+func (_c *MockDevice_GetPropertyReal_Call) Run(run func()) *MockDevice_GetPropertyReal_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyReal_Call) Return(_a0 bool, _a1 error) *MockDevice_GetPropertyReal_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyReal_Call) RunAndReturn(run func() (bool, error)) *MockDevice_GetPropertyReal_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyState provides a mock function with no fields
+func (_m *MockDevice) GetPropertyState() (gonetworkmanager.NmDeviceState, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyState")
+	}
+
+	var r0 gonetworkmanager.NmDeviceState
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmDeviceState, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.NmDeviceState); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(gonetworkmanager.NmDeviceState)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyState'
+type MockDevice_GetPropertyState_Call struct {
+	*mock.Call
+}
+
+// GetPropertyState is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyState() *MockDevice_GetPropertyState_Call {
+	return &MockDevice_GetPropertyState_Call{Call: _e.mock.On("GetPropertyState")}
+}
+
+func (_c *MockDevice_GetPropertyState_Call) Run(run func()) *MockDevice_GetPropertyState_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyState_Call) Return(_a0 gonetworkmanager.NmDeviceState, _a1 error) *MockDevice_GetPropertyState_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyState_Call) RunAndReturn(run func() (gonetworkmanager.NmDeviceState, error)) *MockDevice_GetPropertyState_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyUdi provides a mock function with no fields
+func (_m *MockDevice) GetPropertyUdi() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyUdi")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_GetPropertyUdi_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyUdi'
+type MockDevice_GetPropertyUdi_Call struct {
+	*mock.Call
+}
+
+// GetPropertyUdi is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) GetPropertyUdi() *MockDevice_GetPropertyUdi_Call {
+	return &MockDevice_GetPropertyUdi_Call{Call: _e.mock.On("GetPropertyUdi")}
+}
+
+func (_c *MockDevice_GetPropertyUdi_Call) Run(run func()) *MockDevice_GetPropertyUdi_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyUdi_Call) Return(_a0 string, _a1 error) *MockDevice_GetPropertyUdi_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_GetPropertyUdi_Call) RunAndReturn(run func() (string, error)) *MockDevice_GetPropertyUdi_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// MarshalJSON provides a mock function with no fields
+func (_m *MockDevice) MarshalJSON() ([]byte, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarshalJSON")
+	}
+
+	var r0 []byte
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]byte, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []byte); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]byte)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDevice_MarshalJSON_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarshalJSON'
+type MockDevice_MarshalJSON_Call struct {
+	*mock.Call
+}
+
+// MarshalJSON is a helper method to define mock.On call
+func (_e *MockDevice_Expecter) MarshalJSON() *MockDevice_MarshalJSON_Call {
+	return &MockDevice_MarshalJSON_Call{Call: _e.mock.On("MarshalJSON")}
+}
+
+func (_c *MockDevice_MarshalJSON_Call) Run(run func()) *MockDevice_MarshalJSON_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDevice_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockDevice_MarshalJSON_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDevice_MarshalJSON_Call) RunAndReturn(run func() ([]byte, error)) *MockDevice_MarshalJSON_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Reapply provides a mock function with given fields: connection, versionId, flags
+func (_m *MockDevice) Reapply(connection gonetworkmanager.Connection, versionId uint64, flags uint32) error {
+	ret := _m.Called(connection, versionId, flags)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Reapply")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.Connection, uint64, uint32) error); ok {
+		r0 = rf(connection, versionId, flags)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockDevice_Reapply_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reapply'
+type MockDevice_Reapply_Call struct {
+	*mock.Call
+}
+
+// Reapply is a helper method to define mock.On call
+//   - connection gonetworkmanager.Connection
+//   - versionId uint64
+//   - flags uint32
+func (_e *MockDevice_Expecter) Reapply(connection interface{}, versionId interface{}, flags interface{}) *MockDevice_Reapply_Call {
+	return &MockDevice_Reapply_Call{Call: _e.mock.On("Reapply", connection, versionId, flags)}
+}
+
+func (_c *MockDevice_Reapply_Call) Run(run func(connection gonetworkmanager.Connection, versionId uint64, flags uint32)) *MockDevice_Reapply_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(gonetworkmanager.Connection), args[1].(uint64), args[2].(uint32))
+	})
+	return _c
+}
+
+func (_c *MockDevice_Reapply_Call) Return(_a0 error) *MockDevice_Reapply_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockDevice_Reapply_Call) RunAndReturn(run func(gonetworkmanager.Connection, uint64, uint32) error) *MockDevice_Reapply_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetPropertyAutoConnect provides a mock function with given fields: _a0
+func (_m *MockDevice) SetPropertyAutoConnect(_a0 bool) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetPropertyAutoConnect")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(bool) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockDevice_SetPropertyAutoConnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPropertyAutoConnect'
+type MockDevice_SetPropertyAutoConnect_Call struct {
+	*mock.Call
+}
+
+// SetPropertyAutoConnect is a helper method to define mock.On call
+//   - _a0 bool
+func (_e *MockDevice_Expecter) SetPropertyAutoConnect(_a0 interface{}) *MockDevice_SetPropertyAutoConnect_Call {
+	return &MockDevice_SetPropertyAutoConnect_Call{Call: _e.mock.On("SetPropertyAutoConnect", _a0)}
+}
+
+func (_c *MockDevice_SetPropertyAutoConnect_Call) Run(run func(_a0 bool)) *MockDevice_SetPropertyAutoConnect_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(bool))
+	})
+	return _c
+}
+
+func (_c *MockDevice_SetPropertyAutoConnect_Call) Return(_a0 error) *MockDevice_SetPropertyAutoConnect_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockDevice_SetPropertyAutoConnect_Call) RunAndReturn(run func(bool) error) *MockDevice_SetPropertyAutoConnect_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetPropertyManaged provides a mock function with given fields: _a0
+func (_m *MockDevice) SetPropertyManaged(_a0 bool) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetPropertyManaged")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(bool) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockDevice_SetPropertyManaged_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPropertyManaged'
+type MockDevice_SetPropertyManaged_Call struct {
+	*mock.Call
+}
+
+// SetPropertyManaged is a helper method to define mock.On call
+//   - _a0 bool
+func (_e *MockDevice_Expecter) SetPropertyManaged(_a0 interface{}) *MockDevice_SetPropertyManaged_Call {
+	return &MockDevice_SetPropertyManaged_Call{Call: _e.mock.On("SetPropertyManaged", _a0)}
+}
+
+func (_c *MockDevice_SetPropertyManaged_Call) Run(run func(_a0 bool)) *MockDevice_SetPropertyManaged_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(bool))
+	})
+	return _c
+}
+
+func (_c *MockDevice_SetPropertyManaged_Call) Return(_a0 error) *MockDevice_SetPropertyManaged_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockDevice_SetPropertyManaged_Call) RunAndReturn(run func(bool) error) *MockDevice_SetPropertyManaged_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SubscribeState provides a mock function with given fields: receiver, exit
+func (_m *MockDevice) SubscribeState(receiver chan gonetworkmanager.DeviceStateChange, exit chan struct{}) error {
+	ret := _m.Called(receiver, exit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SubscribeState")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(chan gonetworkmanager.DeviceStateChange, chan struct{}) error); ok {
+		r0 = rf(receiver, exit)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockDevice_SubscribeState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribeState'
+type MockDevice_SubscribeState_Call struct {
+	*mock.Call
+}
+
+// SubscribeState is a helper method to define mock.On call
+//   - receiver chan gonetworkmanager.DeviceStateChange
+//   - exit chan struct{}
+func (_e *MockDevice_Expecter) SubscribeState(receiver interface{}, exit interface{}) *MockDevice_SubscribeState_Call {
+	return &MockDevice_SubscribeState_Call{Call: _e.mock.On("SubscribeState", receiver, exit)}
+}
+
+func (_c *MockDevice_SubscribeState_Call) Run(run func(receiver chan gonetworkmanager.DeviceStateChange, exit chan struct{})) *MockDevice_SubscribeState_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(chan gonetworkmanager.DeviceStateChange), args[1].(chan struct{}))
+	})
+	return _c
+}
+
+func (_c *MockDevice_SubscribeState_Call) Return(err error) *MockDevice_SubscribeState_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockDevice_SubscribeState_Call) RunAndReturn(run func(chan gonetworkmanager.DeviceStateChange, chan struct{}) error) *MockDevice_SubscribeState_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockDevice creates a new instance of MockDevice. 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 NewMockDevice(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockDevice {
+	mock := &MockDevice{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_DeviceWireless.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_DeviceWireless.go
new file mode 100644
index 0000000..d2d3f2d
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_DeviceWireless.go
@@ -0,0 +1,2241 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package gonetworkmanager
+
+import (
+	gonetworkmanager "github.com/Wifx/gonetworkmanager/v2"
+	dbus "github.com/godbus/dbus/v5"
+
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockDeviceWireless is an autogenerated mock type for the DeviceWireless type
+type MockDeviceWireless struct {
+	mock.Mock
+}
+
+type MockDeviceWireless_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockDeviceWireless) EXPECT() *MockDeviceWireless_Expecter {
+	return &MockDeviceWireless_Expecter{mock: &_m.Mock}
+}
+
+// Delete provides a mock function with no fields
+func (_m *MockDeviceWireless) Delete() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Delete")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockDeviceWireless_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
+type MockDeviceWireless_Delete_Call struct {
+	*mock.Call
+}
+
+// Delete is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) Delete() *MockDeviceWireless_Delete_Call {
+	return &MockDeviceWireless_Delete_Call{Call: _e.mock.On("Delete")}
+}
+
+func (_c *MockDeviceWireless_Delete_Call) Run(run func()) *MockDeviceWireless_Delete_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_Delete_Call) Return(_a0 error) *MockDeviceWireless_Delete_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockDeviceWireless_Delete_Call) RunAndReturn(run func() error) *MockDeviceWireless_Delete_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Disconnect provides a mock function with no fields
+func (_m *MockDeviceWireless) Disconnect() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Disconnect")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockDeviceWireless_Disconnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Disconnect'
+type MockDeviceWireless_Disconnect_Call struct {
+	*mock.Call
+}
+
+// Disconnect is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) Disconnect() *MockDeviceWireless_Disconnect_Call {
+	return &MockDeviceWireless_Disconnect_Call{Call: _e.mock.On("Disconnect")}
+}
+
+func (_c *MockDeviceWireless_Disconnect_Call) Run(run func()) *MockDeviceWireless_Disconnect_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_Disconnect_Call) Return(_a0 error) *MockDeviceWireless_Disconnect_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockDeviceWireless_Disconnect_Call) RunAndReturn(run func() error) *MockDeviceWireless_Disconnect_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetAccessPoints provides a mock function with no fields
+func (_m *MockDeviceWireless) GetAccessPoints() ([]gonetworkmanager.AccessPoint, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAccessPoints")
+	}
+
+	var r0 []gonetworkmanager.AccessPoint
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.AccessPoint, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.AccessPoint); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.AccessPoint)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetAccessPoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAccessPoints'
+type MockDeviceWireless_GetAccessPoints_Call struct {
+	*mock.Call
+}
+
+// GetAccessPoints is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetAccessPoints() *MockDeviceWireless_GetAccessPoints_Call {
+	return &MockDeviceWireless_GetAccessPoints_Call{Call: _e.mock.On("GetAccessPoints")}
+}
+
+func (_c *MockDeviceWireless_GetAccessPoints_Call) Run(run func()) *MockDeviceWireless_GetAccessPoints_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetAccessPoints_Call) Return(_a0 []gonetworkmanager.AccessPoint, _a1 error) *MockDeviceWireless_GetAccessPoints_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetAccessPoints_Call) RunAndReturn(run func() ([]gonetworkmanager.AccessPoint, error)) *MockDeviceWireless_GetAccessPoints_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetAllAccessPoints provides a mock function with no fields
+func (_m *MockDeviceWireless) GetAllAccessPoints() ([]gonetworkmanager.AccessPoint, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllAccessPoints")
+	}
+
+	var r0 []gonetworkmanager.AccessPoint
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.AccessPoint, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.AccessPoint); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.AccessPoint)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetAllAccessPoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllAccessPoints'
+type MockDeviceWireless_GetAllAccessPoints_Call struct {
+	*mock.Call
+}
+
+// GetAllAccessPoints is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetAllAccessPoints() *MockDeviceWireless_GetAllAccessPoints_Call {
+	return &MockDeviceWireless_GetAllAccessPoints_Call{Call: _e.mock.On("GetAllAccessPoints")}
+}
+
+func (_c *MockDeviceWireless_GetAllAccessPoints_Call) Run(run func()) *MockDeviceWireless_GetAllAccessPoints_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetAllAccessPoints_Call) Return(_a0 []gonetworkmanager.AccessPoint, _a1 error) *MockDeviceWireless_GetAllAccessPoints_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetAllAccessPoints_Call) RunAndReturn(run func() ([]gonetworkmanager.AccessPoint, error)) *MockDeviceWireless_GetAllAccessPoints_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPath provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPath() dbus.ObjectPath {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPath")
+	}
+
+	var r0 dbus.ObjectPath
+	if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(dbus.ObjectPath)
+	}
+
+	return r0
+}
+
+// MockDeviceWireless_GetPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPath'
+type MockDeviceWireless_GetPath_Call struct {
+	*mock.Call
+}
+
+// GetPath is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPath() *MockDeviceWireless_GetPath_Call {
+	return &MockDeviceWireless_GetPath_Call{Call: _e.mock.On("GetPath")}
+}
+
+func (_c *MockDeviceWireless_GetPath_Call) Run(run func()) *MockDeviceWireless_GetPath_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPath_Call) Return(_a0 dbus.ObjectPath) *MockDeviceWireless_GetPath_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPath_Call) RunAndReturn(run func() dbus.ObjectPath) *MockDeviceWireless_GetPath_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyAccessPoints provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyAccessPoints() ([]gonetworkmanager.AccessPoint, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyAccessPoints")
+	}
+
+	var r0 []gonetworkmanager.AccessPoint
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.AccessPoint, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.AccessPoint); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.AccessPoint)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyAccessPoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAccessPoints'
+type MockDeviceWireless_GetPropertyAccessPoints_Call struct {
+	*mock.Call
+}
+
+// GetPropertyAccessPoints is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyAccessPoints() *MockDeviceWireless_GetPropertyAccessPoints_Call {
+	return &MockDeviceWireless_GetPropertyAccessPoints_Call{Call: _e.mock.On("GetPropertyAccessPoints")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyAccessPoints_Call) Run(run func()) *MockDeviceWireless_GetPropertyAccessPoints_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyAccessPoints_Call) Return(_a0 []gonetworkmanager.AccessPoint, _a1 error) *MockDeviceWireless_GetPropertyAccessPoints_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyAccessPoints_Call) RunAndReturn(run func() ([]gonetworkmanager.AccessPoint, error)) *MockDeviceWireless_GetPropertyAccessPoints_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyActiveAccessPoint provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyActiveAccessPoint() (gonetworkmanager.AccessPoint, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyActiveAccessPoint")
+	}
+
+	var r0 gonetworkmanager.AccessPoint
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.AccessPoint, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.AccessPoint); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.AccessPoint)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyActiveAccessPoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyActiveAccessPoint'
+type MockDeviceWireless_GetPropertyActiveAccessPoint_Call struct {
+	*mock.Call
+}
+
+// GetPropertyActiveAccessPoint is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyActiveAccessPoint() *MockDeviceWireless_GetPropertyActiveAccessPoint_Call {
+	return &MockDeviceWireless_GetPropertyActiveAccessPoint_Call{Call: _e.mock.On("GetPropertyActiveAccessPoint")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyActiveAccessPoint_Call) Run(run func()) *MockDeviceWireless_GetPropertyActiveAccessPoint_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyActiveAccessPoint_Call) Return(_a0 gonetworkmanager.AccessPoint, _a1 error) *MockDeviceWireless_GetPropertyActiveAccessPoint_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyActiveAccessPoint_Call) RunAndReturn(run func() (gonetworkmanager.AccessPoint, error)) *MockDeviceWireless_GetPropertyActiveAccessPoint_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyActiveConnection provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyActiveConnection() (gonetworkmanager.ActiveConnection, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyActiveConnection")
+	}
+
+	var r0 gonetworkmanager.ActiveConnection
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.ActiveConnection, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.ActiveConnection); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.ActiveConnection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyActiveConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyActiveConnection'
+type MockDeviceWireless_GetPropertyActiveConnection_Call struct {
+	*mock.Call
+}
+
+// GetPropertyActiveConnection is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyActiveConnection() *MockDeviceWireless_GetPropertyActiveConnection_Call {
+	return &MockDeviceWireless_GetPropertyActiveConnection_Call{Call: _e.mock.On("GetPropertyActiveConnection")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyActiveConnection_Call) Run(run func()) *MockDeviceWireless_GetPropertyActiveConnection_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyActiveConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockDeviceWireless_GetPropertyActiveConnection_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyActiveConnection_Call) RunAndReturn(run func() (gonetworkmanager.ActiveConnection, error)) *MockDeviceWireless_GetPropertyActiveConnection_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyAutoConnect provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyAutoConnect() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyAutoConnect")
+	}
+
+	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
+}
+
+// MockDeviceWireless_GetPropertyAutoConnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAutoConnect'
+type MockDeviceWireless_GetPropertyAutoConnect_Call struct {
+	*mock.Call
+}
+
+// GetPropertyAutoConnect is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyAutoConnect() *MockDeviceWireless_GetPropertyAutoConnect_Call {
+	return &MockDeviceWireless_GetPropertyAutoConnect_Call{Call: _e.mock.On("GetPropertyAutoConnect")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyAutoConnect_Call) Run(run func()) *MockDeviceWireless_GetPropertyAutoConnect_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyAutoConnect_Call) Return(_a0 bool, _a1 error) *MockDeviceWireless_GetPropertyAutoConnect_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyAutoConnect_Call) RunAndReturn(run func() (bool, error)) *MockDeviceWireless_GetPropertyAutoConnect_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyAvailableConnections provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyAvailableConnections() ([]gonetworkmanager.Connection, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyAvailableConnections")
+	}
+
+	var r0 []gonetworkmanager.Connection
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Connection, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.Connection); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.Connection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyAvailableConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAvailableConnections'
+type MockDeviceWireless_GetPropertyAvailableConnections_Call struct {
+	*mock.Call
+}
+
+// GetPropertyAvailableConnections is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyAvailableConnections() *MockDeviceWireless_GetPropertyAvailableConnections_Call {
+	return &MockDeviceWireless_GetPropertyAvailableConnections_Call{Call: _e.mock.On("GetPropertyAvailableConnections")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyAvailableConnections_Call) Run(run func()) *MockDeviceWireless_GetPropertyAvailableConnections_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyAvailableConnections_Call) Return(_a0 []gonetworkmanager.Connection, _a1 error) *MockDeviceWireless_GetPropertyAvailableConnections_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyAvailableConnections_Call) RunAndReturn(run func() ([]gonetworkmanager.Connection, error)) *MockDeviceWireless_GetPropertyAvailableConnections_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyBitrate provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyBitrate() (uint32, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyBitrate")
+	}
+
+	var r0 uint32
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() uint32); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(uint32)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyBitrate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyBitrate'
+type MockDeviceWireless_GetPropertyBitrate_Call struct {
+	*mock.Call
+}
+
+// GetPropertyBitrate is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyBitrate() *MockDeviceWireless_GetPropertyBitrate_Call {
+	return &MockDeviceWireless_GetPropertyBitrate_Call{Call: _e.mock.On("GetPropertyBitrate")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyBitrate_Call) Run(run func()) *MockDeviceWireless_GetPropertyBitrate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyBitrate_Call) Return(_a0 uint32, _a1 error) *MockDeviceWireless_GetPropertyBitrate_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyBitrate_Call) RunAndReturn(run func() (uint32, error)) *MockDeviceWireless_GetPropertyBitrate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDHCP4Config provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyDHCP4Config() (gonetworkmanager.DHCP4Config, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDHCP4Config")
+	}
+
+	var r0 gonetworkmanager.DHCP4Config
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.DHCP4Config, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.DHCP4Config); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.DHCP4Config)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyDHCP4Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDHCP4Config'
+type MockDeviceWireless_GetPropertyDHCP4Config_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDHCP4Config is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyDHCP4Config() *MockDeviceWireless_GetPropertyDHCP4Config_Call {
+	return &MockDeviceWireless_GetPropertyDHCP4Config_Call{Call: _e.mock.On("GetPropertyDHCP4Config")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyDHCP4Config_Call) Run(run func()) *MockDeviceWireless_GetPropertyDHCP4Config_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyDHCP4Config_Call) Return(_a0 gonetworkmanager.DHCP4Config, _a1 error) *MockDeviceWireless_GetPropertyDHCP4Config_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyDHCP4Config_Call) RunAndReturn(run func() (gonetworkmanager.DHCP4Config, error)) *MockDeviceWireless_GetPropertyDHCP4Config_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDHCP6Config provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyDHCP6Config() (gonetworkmanager.DHCP6Config, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDHCP6Config")
+	}
+
+	var r0 gonetworkmanager.DHCP6Config
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.DHCP6Config, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.DHCP6Config); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.DHCP6Config)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyDHCP6Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDHCP6Config'
+type MockDeviceWireless_GetPropertyDHCP6Config_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDHCP6Config is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyDHCP6Config() *MockDeviceWireless_GetPropertyDHCP6Config_Call {
+	return &MockDeviceWireless_GetPropertyDHCP6Config_Call{Call: _e.mock.On("GetPropertyDHCP6Config")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyDHCP6Config_Call) Run(run func()) *MockDeviceWireless_GetPropertyDHCP6Config_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyDHCP6Config_Call) Return(_a0 gonetworkmanager.DHCP6Config, _a1 error) *MockDeviceWireless_GetPropertyDHCP6Config_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyDHCP6Config_Call) RunAndReturn(run func() (gonetworkmanager.DHCP6Config, error)) *MockDeviceWireless_GetPropertyDHCP6Config_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDeviceType provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyDeviceType() (gonetworkmanager.NmDeviceType, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDeviceType")
+	}
+
+	var r0 gonetworkmanager.NmDeviceType
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmDeviceType, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.NmDeviceType); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(gonetworkmanager.NmDeviceType)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyDeviceType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDeviceType'
+type MockDeviceWireless_GetPropertyDeviceType_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDeviceType is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyDeviceType() *MockDeviceWireless_GetPropertyDeviceType_Call {
+	return &MockDeviceWireless_GetPropertyDeviceType_Call{Call: _e.mock.On("GetPropertyDeviceType")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyDeviceType_Call) Run(run func()) *MockDeviceWireless_GetPropertyDeviceType_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyDeviceType_Call) Return(_a0 gonetworkmanager.NmDeviceType, _a1 error) *MockDeviceWireless_GetPropertyDeviceType_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyDeviceType_Call) RunAndReturn(run func() (gonetworkmanager.NmDeviceType, error)) *MockDeviceWireless_GetPropertyDeviceType_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDriver provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyDriver() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDriver")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyDriver_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDriver'
+type MockDeviceWireless_GetPropertyDriver_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDriver is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyDriver() *MockDeviceWireless_GetPropertyDriver_Call {
+	return &MockDeviceWireless_GetPropertyDriver_Call{Call: _e.mock.On("GetPropertyDriver")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyDriver_Call) Run(run func()) *MockDeviceWireless_GetPropertyDriver_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyDriver_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyDriver_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyDriver_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyDriver_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDriverVersion provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyDriverVersion() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDriverVersion")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyDriverVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDriverVersion'
+type MockDeviceWireless_GetPropertyDriverVersion_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDriverVersion is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyDriverVersion() *MockDeviceWireless_GetPropertyDriverVersion_Call {
+	return &MockDeviceWireless_GetPropertyDriverVersion_Call{Call: _e.mock.On("GetPropertyDriverVersion")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyDriverVersion_Call) Run(run func()) *MockDeviceWireless_GetPropertyDriverVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyDriverVersion_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyDriverVersion_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyDriverVersion_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyDriverVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyFirmwareMissing provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyFirmwareMissing() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyFirmwareMissing")
+	}
+
+	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
+}
+
+// MockDeviceWireless_GetPropertyFirmwareMissing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFirmwareMissing'
+type MockDeviceWireless_GetPropertyFirmwareMissing_Call struct {
+	*mock.Call
+}
+
+// GetPropertyFirmwareMissing is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyFirmwareMissing() *MockDeviceWireless_GetPropertyFirmwareMissing_Call {
+	return &MockDeviceWireless_GetPropertyFirmwareMissing_Call{Call: _e.mock.On("GetPropertyFirmwareMissing")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyFirmwareMissing_Call) Run(run func()) *MockDeviceWireless_GetPropertyFirmwareMissing_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyFirmwareMissing_Call) Return(_a0 bool, _a1 error) *MockDeviceWireless_GetPropertyFirmwareMissing_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyFirmwareMissing_Call) RunAndReturn(run func() (bool, error)) *MockDeviceWireless_GetPropertyFirmwareMissing_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyFirmwareVersion provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyFirmwareVersion() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyFirmwareVersion")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyFirmwareVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyFirmwareVersion'
+type MockDeviceWireless_GetPropertyFirmwareVersion_Call struct {
+	*mock.Call
+}
+
+// GetPropertyFirmwareVersion is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyFirmwareVersion() *MockDeviceWireless_GetPropertyFirmwareVersion_Call {
+	return &MockDeviceWireless_GetPropertyFirmwareVersion_Call{Call: _e.mock.On("GetPropertyFirmwareVersion")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyFirmwareVersion_Call) Run(run func()) *MockDeviceWireless_GetPropertyFirmwareVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyFirmwareVersion_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyFirmwareVersion_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyFirmwareVersion_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyFirmwareVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyHwAddress provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyHwAddress() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyHwAddress")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyHwAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyHwAddress'
+type MockDeviceWireless_GetPropertyHwAddress_Call struct {
+	*mock.Call
+}
+
+// GetPropertyHwAddress is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyHwAddress() *MockDeviceWireless_GetPropertyHwAddress_Call {
+	return &MockDeviceWireless_GetPropertyHwAddress_Call{Call: _e.mock.On("GetPropertyHwAddress")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyHwAddress_Call) Run(run func()) *MockDeviceWireless_GetPropertyHwAddress_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyHwAddress_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyHwAddress_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyHwAddress_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyHwAddress_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyIP4Config provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyIP4Config() (gonetworkmanager.IP4Config, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyIP4Config")
+	}
+
+	var r0 gonetworkmanager.IP4Config
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.IP4Config, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.IP4Config); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.IP4Config)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyIP4Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIP4Config'
+type MockDeviceWireless_GetPropertyIP4Config_Call struct {
+	*mock.Call
+}
+
+// GetPropertyIP4Config is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyIP4Config() *MockDeviceWireless_GetPropertyIP4Config_Call {
+	return &MockDeviceWireless_GetPropertyIP4Config_Call{Call: _e.mock.On("GetPropertyIP4Config")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyIP4Config_Call) Run(run func()) *MockDeviceWireless_GetPropertyIP4Config_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyIP4Config_Call) Return(_a0 gonetworkmanager.IP4Config, _a1 error) *MockDeviceWireless_GetPropertyIP4Config_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyIP4Config_Call) RunAndReturn(run func() (gonetworkmanager.IP4Config, error)) *MockDeviceWireless_GetPropertyIP4Config_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyIP6Config provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyIP6Config() (gonetworkmanager.IP6Config, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyIP6Config")
+	}
+
+	var r0 gonetworkmanager.IP6Config
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.IP6Config, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.IP6Config); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.IP6Config)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyIP6Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIP6Config'
+type MockDeviceWireless_GetPropertyIP6Config_Call struct {
+	*mock.Call
+}
+
+// GetPropertyIP6Config is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyIP6Config() *MockDeviceWireless_GetPropertyIP6Config_Call {
+	return &MockDeviceWireless_GetPropertyIP6Config_Call{Call: _e.mock.On("GetPropertyIP6Config")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyIP6Config_Call) Run(run func()) *MockDeviceWireless_GetPropertyIP6Config_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyIP6Config_Call) Return(_a0 gonetworkmanager.IP6Config, _a1 error) *MockDeviceWireless_GetPropertyIP6Config_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyIP6Config_Call) RunAndReturn(run func() (gonetworkmanager.IP6Config, error)) *MockDeviceWireless_GetPropertyIP6Config_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyInterface provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyInterface() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyInterface")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyInterface'
+type MockDeviceWireless_GetPropertyInterface_Call struct {
+	*mock.Call
+}
+
+// GetPropertyInterface is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyInterface() *MockDeviceWireless_GetPropertyInterface_Call {
+	return &MockDeviceWireless_GetPropertyInterface_Call{Call: _e.mock.On("GetPropertyInterface")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyInterface_Call) Run(run func()) *MockDeviceWireless_GetPropertyInterface_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyInterface_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyInterface_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyInterface_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyInterface_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyIp4Connectivity provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyIp4Connectivity() (gonetworkmanager.NmConnectivity, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyIp4Connectivity")
+	}
+
+	var r0 gonetworkmanager.NmConnectivity
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmConnectivity, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.NmConnectivity); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(gonetworkmanager.NmConnectivity)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyIp4Connectivity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIp4Connectivity'
+type MockDeviceWireless_GetPropertyIp4Connectivity_Call struct {
+	*mock.Call
+}
+
+// GetPropertyIp4Connectivity is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyIp4Connectivity() *MockDeviceWireless_GetPropertyIp4Connectivity_Call {
+	return &MockDeviceWireless_GetPropertyIp4Connectivity_Call{Call: _e.mock.On("GetPropertyIp4Connectivity")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyIp4Connectivity_Call) Run(run func()) *MockDeviceWireless_GetPropertyIp4Connectivity_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyIp4Connectivity_Call) Return(_a0 gonetworkmanager.NmConnectivity, _a1 error) *MockDeviceWireless_GetPropertyIp4Connectivity_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyIp4Connectivity_Call) RunAndReturn(run func() (gonetworkmanager.NmConnectivity, error)) *MockDeviceWireless_GetPropertyIp4Connectivity_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyIpInterface provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyIpInterface() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyIpInterface")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyIpInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyIpInterface'
+type MockDeviceWireless_GetPropertyIpInterface_Call struct {
+	*mock.Call
+}
+
+// GetPropertyIpInterface is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyIpInterface() *MockDeviceWireless_GetPropertyIpInterface_Call {
+	return &MockDeviceWireless_GetPropertyIpInterface_Call{Call: _e.mock.On("GetPropertyIpInterface")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyIpInterface_Call) Run(run func()) *MockDeviceWireless_GetPropertyIpInterface_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyIpInterface_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyIpInterface_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyIpInterface_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyIpInterface_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyLastScan provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyLastScan() (int64, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyLastScan")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (int64, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() int64); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyLastScan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyLastScan'
+type MockDeviceWireless_GetPropertyLastScan_Call struct {
+	*mock.Call
+}
+
+// GetPropertyLastScan is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyLastScan() *MockDeviceWireless_GetPropertyLastScan_Call {
+	return &MockDeviceWireless_GetPropertyLastScan_Call{Call: _e.mock.On("GetPropertyLastScan")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyLastScan_Call) Run(run func()) *MockDeviceWireless_GetPropertyLastScan_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyLastScan_Call) Return(_a0 int64, _a1 error) *MockDeviceWireless_GetPropertyLastScan_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyLastScan_Call) RunAndReturn(run func() (int64, error)) *MockDeviceWireless_GetPropertyLastScan_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyManaged provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyManaged() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyManaged")
+	}
+
+	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
+}
+
+// MockDeviceWireless_GetPropertyManaged_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyManaged'
+type MockDeviceWireless_GetPropertyManaged_Call struct {
+	*mock.Call
+}
+
+// GetPropertyManaged is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyManaged() *MockDeviceWireless_GetPropertyManaged_Call {
+	return &MockDeviceWireless_GetPropertyManaged_Call{Call: _e.mock.On("GetPropertyManaged")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyManaged_Call) Run(run func()) *MockDeviceWireless_GetPropertyManaged_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyManaged_Call) Return(_a0 bool, _a1 error) *MockDeviceWireless_GetPropertyManaged_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyManaged_Call) RunAndReturn(run func() (bool, error)) *MockDeviceWireless_GetPropertyManaged_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyMode provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyMode() (gonetworkmanager.Nm80211Mode, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyMode")
+	}
+
+	var r0 gonetworkmanager.Nm80211Mode
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.Nm80211Mode, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.Nm80211Mode); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(gonetworkmanager.Nm80211Mode)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyMode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyMode'
+type MockDeviceWireless_GetPropertyMode_Call struct {
+	*mock.Call
+}
+
+// GetPropertyMode is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyMode() *MockDeviceWireless_GetPropertyMode_Call {
+	return &MockDeviceWireless_GetPropertyMode_Call{Call: _e.mock.On("GetPropertyMode")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyMode_Call) Run(run func()) *MockDeviceWireless_GetPropertyMode_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyMode_Call) Return(_a0 gonetworkmanager.Nm80211Mode, _a1 error) *MockDeviceWireless_GetPropertyMode_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyMode_Call) RunAndReturn(run func() (gonetworkmanager.Nm80211Mode, error)) *MockDeviceWireless_GetPropertyMode_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyMtu provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyMtu() (uint32, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyMtu")
+	}
+
+	var r0 uint32
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() uint32); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(uint32)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyMtu_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyMtu'
+type MockDeviceWireless_GetPropertyMtu_Call struct {
+	*mock.Call
+}
+
+// GetPropertyMtu is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyMtu() *MockDeviceWireless_GetPropertyMtu_Call {
+	return &MockDeviceWireless_GetPropertyMtu_Call{Call: _e.mock.On("GetPropertyMtu")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyMtu_Call) Run(run func()) *MockDeviceWireless_GetPropertyMtu_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyMtu_Call) Return(_a0 uint32, _a1 error) *MockDeviceWireless_GetPropertyMtu_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyMtu_Call) RunAndReturn(run func() (uint32, error)) *MockDeviceWireless_GetPropertyMtu_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyNmPluginMissing provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyNmPluginMissing() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyNmPluginMissing")
+	}
+
+	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
+}
+
+// MockDeviceWireless_GetPropertyNmPluginMissing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyNmPluginMissing'
+type MockDeviceWireless_GetPropertyNmPluginMissing_Call struct {
+	*mock.Call
+}
+
+// GetPropertyNmPluginMissing is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyNmPluginMissing() *MockDeviceWireless_GetPropertyNmPluginMissing_Call {
+	return &MockDeviceWireless_GetPropertyNmPluginMissing_Call{Call: _e.mock.On("GetPropertyNmPluginMissing")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyNmPluginMissing_Call) Run(run func()) *MockDeviceWireless_GetPropertyNmPluginMissing_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyNmPluginMissing_Call) Return(_a0 bool, _a1 error) *MockDeviceWireless_GetPropertyNmPluginMissing_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyNmPluginMissing_Call) RunAndReturn(run func() (bool, error)) *MockDeviceWireless_GetPropertyNmPluginMissing_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyPermHwAddress provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyPermHwAddress() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyPermHwAddress")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyPermHwAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyPermHwAddress'
+type MockDeviceWireless_GetPropertyPermHwAddress_Call struct {
+	*mock.Call
+}
+
+// GetPropertyPermHwAddress is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyPermHwAddress() *MockDeviceWireless_GetPropertyPermHwAddress_Call {
+	return &MockDeviceWireless_GetPropertyPermHwAddress_Call{Call: _e.mock.On("GetPropertyPermHwAddress")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyPermHwAddress_Call) Run(run func()) *MockDeviceWireless_GetPropertyPermHwAddress_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyPermHwAddress_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyPermHwAddress_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyPermHwAddress_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyPermHwAddress_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyPhysicalPortId provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyPhysicalPortId() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyPhysicalPortId")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyPhysicalPortId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyPhysicalPortId'
+type MockDeviceWireless_GetPropertyPhysicalPortId_Call struct {
+	*mock.Call
+}
+
+// GetPropertyPhysicalPortId is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyPhysicalPortId() *MockDeviceWireless_GetPropertyPhysicalPortId_Call {
+	return &MockDeviceWireless_GetPropertyPhysicalPortId_Call{Call: _e.mock.On("GetPropertyPhysicalPortId")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyPhysicalPortId_Call) Run(run func()) *MockDeviceWireless_GetPropertyPhysicalPortId_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyPhysicalPortId_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyPhysicalPortId_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyPhysicalPortId_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyPhysicalPortId_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyReal provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyReal() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyReal")
+	}
+
+	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
+}
+
+// MockDeviceWireless_GetPropertyReal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyReal'
+type MockDeviceWireless_GetPropertyReal_Call struct {
+	*mock.Call
+}
+
+// GetPropertyReal is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyReal() *MockDeviceWireless_GetPropertyReal_Call {
+	return &MockDeviceWireless_GetPropertyReal_Call{Call: _e.mock.On("GetPropertyReal")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyReal_Call) Run(run func()) *MockDeviceWireless_GetPropertyReal_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyReal_Call) Return(_a0 bool, _a1 error) *MockDeviceWireless_GetPropertyReal_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyReal_Call) RunAndReturn(run func() (bool, error)) *MockDeviceWireless_GetPropertyReal_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyState provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyState() (gonetworkmanager.NmDeviceState, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyState")
+	}
+
+	var r0 gonetworkmanager.NmDeviceState
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmDeviceState, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.NmDeviceState); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(gonetworkmanager.NmDeviceState)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyState'
+type MockDeviceWireless_GetPropertyState_Call struct {
+	*mock.Call
+}
+
+// GetPropertyState is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyState() *MockDeviceWireless_GetPropertyState_Call {
+	return &MockDeviceWireless_GetPropertyState_Call{Call: _e.mock.On("GetPropertyState")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyState_Call) Run(run func()) *MockDeviceWireless_GetPropertyState_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyState_Call) Return(_a0 gonetworkmanager.NmDeviceState, _a1 error) *MockDeviceWireless_GetPropertyState_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyState_Call) RunAndReturn(run func() (gonetworkmanager.NmDeviceState, error)) *MockDeviceWireless_GetPropertyState_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyUdi provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyUdi() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyUdi")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyUdi_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyUdi'
+type MockDeviceWireless_GetPropertyUdi_Call struct {
+	*mock.Call
+}
+
+// GetPropertyUdi is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyUdi() *MockDeviceWireless_GetPropertyUdi_Call {
+	return &MockDeviceWireless_GetPropertyUdi_Call{Call: _e.mock.On("GetPropertyUdi")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyUdi_Call) Run(run func()) *MockDeviceWireless_GetPropertyUdi_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyUdi_Call) Return(_a0 string, _a1 error) *MockDeviceWireless_GetPropertyUdi_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyUdi_Call) RunAndReturn(run func() (string, error)) *MockDeviceWireless_GetPropertyUdi_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyWirelessCapabilities provides a mock function with no fields
+func (_m *MockDeviceWireless) GetPropertyWirelessCapabilities() (uint32, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyWirelessCapabilities")
+	}
+
+	var r0 uint32
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() uint32); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(uint32)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_GetPropertyWirelessCapabilities_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWirelessCapabilities'
+type MockDeviceWireless_GetPropertyWirelessCapabilities_Call struct {
+	*mock.Call
+}
+
+// GetPropertyWirelessCapabilities is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) GetPropertyWirelessCapabilities() *MockDeviceWireless_GetPropertyWirelessCapabilities_Call {
+	return &MockDeviceWireless_GetPropertyWirelessCapabilities_Call{Call: _e.mock.On("GetPropertyWirelessCapabilities")}
+}
+
+func (_c *MockDeviceWireless_GetPropertyWirelessCapabilities_Call) Run(run func()) *MockDeviceWireless_GetPropertyWirelessCapabilities_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyWirelessCapabilities_Call) Return(_a0 uint32, _a1 error) *MockDeviceWireless_GetPropertyWirelessCapabilities_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_GetPropertyWirelessCapabilities_Call) RunAndReturn(run func() (uint32, error)) *MockDeviceWireless_GetPropertyWirelessCapabilities_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// MarshalJSON provides a mock function with no fields
+func (_m *MockDeviceWireless) MarshalJSON() ([]byte, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarshalJSON")
+	}
+
+	var r0 []byte
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]byte, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []byte); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]byte)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockDeviceWireless_MarshalJSON_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarshalJSON'
+type MockDeviceWireless_MarshalJSON_Call struct {
+	*mock.Call
+}
+
+// MarshalJSON is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) MarshalJSON() *MockDeviceWireless_MarshalJSON_Call {
+	return &MockDeviceWireless_MarshalJSON_Call{Call: _e.mock.On("MarshalJSON")}
+}
+
+func (_c *MockDeviceWireless_MarshalJSON_Call) Run(run func()) *MockDeviceWireless_MarshalJSON_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockDeviceWireless_MarshalJSON_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockDeviceWireless_MarshalJSON_Call) RunAndReturn(run func() ([]byte, error)) *MockDeviceWireless_MarshalJSON_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Reapply provides a mock function with given fields: connection, versionId, flags
+func (_m *MockDeviceWireless) Reapply(connection gonetworkmanager.Connection, versionId uint64, flags uint32) error {
+	ret := _m.Called(connection, versionId, flags)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Reapply")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.Connection, uint64, uint32) error); ok {
+		r0 = rf(connection, versionId, flags)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockDeviceWireless_Reapply_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reapply'
+type MockDeviceWireless_Reapply_Call struct {
+	*mock.Call
+}
+
+// Reapply is a helper method to define mock.On call
+//   - connection gonetworkmanager.Connection
+//   - versionId uint64
+//   - flags uint32
+func (_e *MockDeviceWireless_Expecter) Reapply(connection interface{}, versionId interface{}, flags interface{}) *MockDeviceWireless_Reapply_Call {
+	return &MockDeviceWireless_Reapply_Call{Call: _e.mock.On("Reapply", connection, versionId, flags)}
+}
+
+func (_c *MockDeviceWireless_Reapply_Call) Run(run func(connection gonetworkmanager.Connection, versionId uint64, flags uint32)) *MockDeviceWireless_Reapply_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(gonetworkmanager.Connection), args[1].(uint64), args[2].(uint32))
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_Reapply_Call) Return(_a0 error) *MockDeviceWireless_Reapply_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockDeviceWireless_Reapply_Call) RunAndReturn(run func(gonetworkmanager.Connection, uint64, uint32) error) *MockDeviceWireless_Reapply_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RequestScan provides a mock function with no fields
+func (_m *MockDeviceWireless) RequestScan() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for RequestScan")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockDeviceWireless_RequestScan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestScan'
+type MockDeviceWireless_RequestScan_Call struct {
+	*mock.Call
+}
+
+// RequestScan is a helper method to define mock.On call
+func (_e *MockDeviceWireless_Expecter) RequestScan() *MockDeviceWireless_RequestScan_Call {
+	return &MockDeviceWireless_RequestScan_Call{Call: _e.mock.On("RequestScan")}
+}
+
+func (_c *MockDeviceWireless_RequestScan_Call) Run(run func()) *MockDeviceWireless_RequestScan_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_RequestScan_Call) Return(_a0 error) *MockDeviceWireless_RequestScan_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockDeviceWireless_RequestScan_Call) RunAndReturn(run func() error) *MockDeviceWireless_RequestScan_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetPropertyAutoConnect provides a mock function with given fields: _a0
+func (_m *MockDeviceWireless) SetPropertyAutoConnect(_a0 bool) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetPropertyAutoConnect")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(bool) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockDeviceWireless_SetPropertyAutoConnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPropertyAutoConnect'
+type MockDeviceWireless_SetPropertyAutoConnect_Call struct {
+	*mock.Call
+}
+
+// SetPropertyAutoConnect is a helper method to define mock.On call
+//   - _a0 bool
+func (_e *MockDeviceWireless_Expecter) SetPropertyAutoConnect(_a0 interface{}) *MockDeviceWireless_SetPropertyAutoConnect_Call {
+	return &MockDeviceWireless_SetPropertyAutoConnect_Call{Call: _e.mock.On("SetPropertyAutoConnect", _a0)}
+}
+
+func (_c *MockDeviceWireless_SetPropertyAutoConnect_Call) Run(run func(_a0 bool)) *MockDeviceWireless_SetPropertyAutoConnect_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(bool))
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_SetPropertyAutoConnect_Call) Return(_a0 error) *MockDeviceWireless_SetPropertyAutoConnect_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockDeviceWireless_SetPropertyAutoConnect_Call) RunAndReturn(run func(bool) error) *MockDeviceWireless_SetPropertyAutoConnect_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetPropertyManaged provides a mock function with given fields: _a0
+func (_m *MockDeviceWireless) SetPropertyManaged(_a0 bool) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetPropertyManaged")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(bool) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockDeviceWireless_SetPropertyManaged_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPropertyManaged'
+type MockDeviceWireless_SetPropertyManaged_Call struct {
+	*mock.Call
+}
+
+// SetPropertyManaged is a helper method to define mock.On call
+//   - _a0 bool
+func (_e *MockDeviceWireless_Expecter) SetPropertyManaged(_a0 interface{}) *MockDeviceWireless_SetPropertyManaged_Call {
+	return &MockDeviceWireless_SetPropertyManaged_Call{Call: _e.mock.On("SetPropertyManaged", _a0)}
+}
+
+func (_c *MockDeviceWireless_SetPropertyManaged_Call) Run(run func(_a0 bool)) *MockDeviceWireless_SetPropertyManaged_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(bool))
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_SetPropertyManaged_Call) Return(_a0 error) *MockDeviceWireless_SetPropertyManaged_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockDeviceWireless_SetPropertyManaged_Call) RunAndReturn(run func(bool) error) *MockDeviceWireless_SetPropertyManaged_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SubscribeState provides a mock function with given fields: receiver, exit
+func (_m *MockDeviceWireless) SubscribeState(receiver chan gonetworkmanager.DeviceStateChange, exit chan struct{}) error {
+	ret := _m.Called(receiver, exit)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SubscribeState")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(chan gonetworkmanager.DeviceStateChange, chan struct{}) error); ok {
+		r0 = rf(receiver, exit)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockDeviceWireless_SubscribeState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribeState'
+type MockDeviceWireless_SubscribeState_Call struct {
+	*mock.Call
+}
+
+// SubscribeState is a helper method to define mock.On call
+//   - receiver chan gonetworkmanager.DeviceStateChange
+//   - exit chan struct{}
+func (_e *MockDeviceWireless_Expecter) SubscribeState(receiver interface{}, exit interface{}) *MockDeviceWireless_SubscribeState_Call {
+	return &MockDeviceWireless_SubscribeState_Call{Call: _e.mock.On("SubscribeState", receiver, exit)}
+}
+
+func (_c *MockDeviceWireless_SubscribeState_Call) Run(run func(receiver chan gonetworkmanager.DeviceStateChange, exit chan struct{})) *MockDeviceWireless_SubscribeState_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(chan gonetworkmanager.DeviceStateChange), args[1].(chan struct{}))
+	})
+	return _c
+}
+
+func (_c *MockDeviceWireless_SubscribeState_Call) Return(err error) *MockDeviceWireless_SubscribeState_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockDeviceWireless_SubscribeState_Call) RunAndReturn(run func(chan gonetworkmanager.DeviceStateChange, chan struct{}) error) *MockDeviceWireless_SubscribeState_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockDeviceWireless creates a new instance of MockDeviceWireless. 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 NewMockDeviceWireless(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockDeviceWireless {
+	mock := &MockDeviceWireless{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_IP4Config.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_IP4Config.go
new file mode 100644
index 0000000..235be86
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_IP4Config.go
@@ -0,0 +1,772 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package gonetworkmanager
+
+import (
+	gonetworkmanager "github.com/Wifx/gonetworkmanager/v2"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockIP4Config is an autogenerated mock type for the IP4Config type
+type MockIP4Config struct {
+	mock.Mock
+}
+
+type MockIP4Config_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockIP4Config) EXPECT() *MockIP4Config_Expecter {
+	return &MockIP4Config_Expecter{mock: &_m.Mock}
+}
+
+// GetPropertyAddressData provides a mock function with no fields
+func (_m *MockIP4Config) GetPropertyAddressData() ([]gonetworkmanager.IP4AddressData, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyAddressData")
+	}
+
+	var r0 []gonetworkmanager.IP4AddressData
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4AddressData, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.IP4AddressData); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.IP4AddressData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockIP4Config_GetPropertyAddressData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAddressData'
+type MockIP4Config_GetPropertyAddressData_Call struct {
+	*mock.Call
+}
+
+// GetPropertyAddressData is a helper method to define mock.On call
+func (_e *MockIP4Config_Expecter) GetPropertyAddressData() *MockIP4Config_GetPropertyAddressData_Call {
+	return &MockIP4Config_GetPropertyAddressData_Call{Call: _e.mock.On("GetPropertyAddressData")}
+}
+
+func (_c *MockIP4Config_GetPropertyAddressData_Call) Run(run func()) *MockIP4Config_GetPropertyAddressData_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyAddressData_Call) Return(_a0 []gonetworkmanager.IP4AddressData, _a1 error) *MockIP4Config_GetPropertyAddressData_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyAddressData_Call) RunAndReturn(run func() ([]gonetworkmanager.IP4AddressData, error)) *MockIP4Config_GetPropertyAddressData_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyAddresses provides a mock function with no fields
+func (_m *MockIP4Config) GetPropertyAddresses() ([]gonetworkmanager.IP4Address, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyAddresses")
+	}
+
+	var r0 []gonetworkmanager.IP4Address
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4Address, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.IP4Address); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.IP4Address)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockIP4Config_GetPropertyAddresses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAddresses'
+type MockIP4Config_GetPropertyAddresses_Call struct {
+	*mock.Call
+}
+
+// GetPropertyAddresses is a helper method to define mock.On call
+func (_e *MockIP4Config_Expecter) GetPropertyAddresses() *MockIP4Config_GetPropertyAddresses_Call {
+	return &MockIP4Config_GetPropertyAddresses_Call{Call: _e.mock.On("GetPropertyAddresses")}
+}
+
+func (_c *MockIP4Config_GetPropertyAddresses_Call) Run(run func()) *MockIP4Config_GetPropertyAddresses_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyAddresses_Call) Return(_a0 []gonetworkmanager.IP4Address, _a1 error) *MockIP4Config_GetPropertyAddresses_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyAddresses_Call) RunAndReturn(run func() ([]gonetworkmanager.IP4Address, error)) *MockIP4Config_GetPropertyAddresses_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDnsOptions provides a mock function with no fields
+func (_m *MockIP4Config) GetPropertyDnsOptions() ([]string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDnsOptions")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []string); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockIP4Config_GetPropertyDnsOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDnsOptions'
+type MockIP4Config_GetPropertyDnsOptions_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDnsOptions is a helper method to define mock.On call
+func (_e *MockIP4Config_Expecter) GetPropertyDnsOptions() *MockIP4Config_GetPropertyDnsOptions_Call {
+	return &MockIP4Config_GetPropertyDnsOptions_Call{Call: _e.mock.On("GetPropertyDnsOptions")}
+}
+
+func (_c *MockIP4Config_GetPropertyDnsOptions_Call) Run(run func()) *MockIP4Config_GetPropertyDnsOptions_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyDnsOptions_Call) Return(_a0 []string, _a1 error) *MockIP4Config_GetPropertyDnsOptions_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyDnsOptions_Call) RunAndReturn(run func() ([]string, error)) *MockIP4Config_GetPropertyDnsOptions_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDnsPriority provides a mock function with no fields
+func (_m *MockIP4Config) GetPropertyDnsPriority() (uint32, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDnsPriority")
+	}
+
+	var r0 uint32
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() uint32); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(uint32)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockIP4Config_GetPropertyDnsPriority_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDnsPriority'
+type MockIP4Config_GetPropertyDnsPriority_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDnsPriority is a helper method to define mock.On call
+func (_e *MockIP4Config_Expecter) GetPropertyDnsPriority() *MockIP4Config_GetPropertyDnsPriority_Call {
+	return &MockIP4Config_GetPropertyDnsPriority_Call{Call: _e.mock.On("GetPropertyDnsPriority")}
+}
+
+func (_c *MockIP4Config_GetPropertyDnsPriority_Call) Run(run func()) *MockIP4Config_GetPropertyDnsPriority_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyDnsPriority_Call) Return(_a0 uint32, _a1 error) *MockIP4Config_GetPropertyDnsPriority_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyDnsPriority_Call) RunAndReturn(run func() (uint32, error)) *MockIP4Config_GetPropertyDnsPriority_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDomains provides a mock function with no fields
+func (_m *MockIP4Config) GetPropertyDomains() ([]string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDomains")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []string); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockIP4Config_GetPropertyDomains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDomains'
+type MockIP4Config_GetPropertyDomains_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDomains is a helper method to define mock.On call
+func (_e *MockIP4Config_Expecter) GetPropertyDomains() *MockIP4Config_GetPropertyDomains_Call {
+	return &MockIP4Config_GetPropertyDomains_Call{Call: _e.mock.On("GetPropertyDomains")}
+}
+
+func (_c *MockIP4Config_GetPropertyDomains_Call) Run(run func()) *MockIP4Config_GetPropertyDomains_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyDomains_Call) Return(_a0 []string, _a1 error) *MockIP4Config_GetPropertyDomains_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyDomains_Call) RunAndReturn(run func() ([]string, error)) *MockIP4Config_GetPropertyDomains_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyGateway provides a mock function with no fields
+func (_m *MockIP4Config) GetPropertyGateway() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyGateway")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockIP4Config_GetPropertyGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyGateway'
+type MockIP4Config_GetPropertyGateway_Call struct {
+	*mock.Call
+}
+
+// GetPropertyGateway is a helper method to define mock.On call
+func (_e *MockIP4Config_Expecter) GetPropertyGateway() *MockIP4Config_GetPropertyGateway_Call {
+	return &MockIP4Config_GetPropertyGateway_Call{Call: _e.mock.On("GetPropertyGateway")}
+}
+
+func (_c *MockIP4Config_GetPropertyGateway_Call) Run(run func()) *MockIP4Config_GetPropertyGateway_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyGateway_Call) Return(_a0 string, _a1 error) *MockIP4Config_GetPropertyGateway_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyGateway_Call) RunAndReturn(run func() (string, error)) *MockIP4Config_GetPropertyGateway_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyNameserverData provides a mock function with no fields
+func (_m *MockIP4Config) GetPropertyNameserverData() ([]gonetworkmanager.IP4NameserverData, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyNameserverData")
+	}
+
+	var r0 []gonetworkmanager.IP4NameserverData
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4NameserverData, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.IP4NameserverData); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.IP4NameserverData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockIP4Config_GetPropertyNameserverData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyNameserverData'
+type MockIP4Config_GetPropertyNameserverData_Call struct {
+	*mock.Call
+}
+
+// GetPropertyNameserverData is a helper method to define mock.On call
+func (_e *MockIP4Config_Expecter) GetPropertyNameserverData() *MockIP4Config_GetPropertyNameserverData_Call {
+	return &MockIP4Config_GetPropertyNameserverData_Call{Call: _e.mock.On("GetPropertyNameserverData")}
+}
+
+func (_c *MockIP4Config_GetPropertyNameserverData_Call) Run(run func()) *MockIP4Config_GetPropertyNameserverData_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyNameserverData_Call) Return(_a0 []gonetworkmanager.IP4NameserverData, _a1 error) *MockIP4Config_GetPropertyNameserverData_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyNameserverData_Call) RunAndReturn(run func() ([]gonetworkmanager.IP4NameserverData, error)) *MockIP4Config_GetPropertyNameserverData_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyNameservers provides a mock function with no fields
+func (_m *MockIP4Config) GetPropertyNameservers() ([]string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyNameservers")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []string); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockIP4Config_GetPropertyNameservers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyNameservers'
+type MockIP4Config_GetPropertyNameservers_Call struct {
+	*mock.Call
+}
+
+// GetPropertyNameservers is a helper method to define mock.On call
+func (_e *MockIP4Config_Expecter) GetPropertyNameservers() *MockIP4Config_GetPropertyNameservers_Call {
+	return &MockIP4Config_GetPropertyNameservers_Call{Call: _e.mock.On("GetPropertyNameservers")}
+}
+
+func (_c *MockIP4Config_GetPropertyNameservers_Call) Run(run func()) *MockIP4Config_GetPropertyNameservers_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyNameservers_Call) Return(_a0 []string, _a1 error) *MockIP4Config_GetPropertyNameservers_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyNameservers_Call) RunAndReturn(run func() ([]string, error)) *MockIP4Config_GetPropertyNameservers_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyRouteData provides a mock function with no fields
+func (_m *MockIP4Config) GetPropertyRouteData() ([]gonetworkmanager.IP4RouteData, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyRouteData")
+	}
+
+	var r0 []gonetworkmanager.IP4RouteData
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4RouteData, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.IP4RouteData); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.IP4RouteData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockIP4Config_GetPropertyRouteData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyRouteData'
+type MockIP4Config_GetPropertyRouteData_Call struct {
+	*mock.Call
+}
+
+// GetPropertyRouteData is a helper method to define mock.On call
+func (_e *MockIP4Config_Expecter) GetPropertyRouteData() *MockIP4Config_GetPropertyRouteData_Call {
+	return &MockIP4Config_GetPropertyRouteData_Call{Call: _e.mock.On("GetPropertyRouteData")}
+}
+
+func (_c *MockIP4Config_GetPropertyRouteData_Call) Run(run func()) *MockIP4Config_GetPropertyRouteData_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyRouteData_Call) Return(_a0 []gonetworkmanager.IP4RouteData, _a1 error) *MockIP4Config_GetPropertyRouteData_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyRouteData_Call) RunAndReturn(run func() ([]gonetworkmanager.IP4RouteData, error)) *MockIP4Config_GetPropertyRouteData_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyRoutes provides a mock function with no fields
+func (_m *MockIP4Config) GetPropertyRoutes() ([]gonetworkmanager.IP4Route, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyRoutes")
+	}
+
+	var r0 []gonetworkmanager.IP4Route
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4Route, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.IP4Route); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.IP4Route)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockIP4Config_GetPropertyRoutes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyRoutes'
+type MockIP4Config_GetPropertyRoutes_Call struct {
+	*mock.Call
+}
+
+// GetPropertyRoutes is a helper method to define mock.On call
+func (_e *MockIP4Config_Expecter) GetPropertyRoutes() *MockIP4Config_GetPropertyRoutes_Call {
+	return &MockIP4Config_GetPropertyRoutes_Call{Call: _e.mock.On("GetPropertyRoutes")}
+}
+
+func (_c *MockIP4Config_GetPropertyRoutes_Call) Run(run func()) *MockIP4Config_GetPropertyRoutes_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyRoutes_Call) Return(_a0 []gonetworkmanager.IP4Route, _a1 error) *MockIP4Config_GetPropertyRoutes_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyRoutes_Call) RunAndReturn(run func() ([]gonetworkmanager.IP4Route, error)) *MockIP4Config_GetPropertyRoutes_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertySearches provides a mock function with no fields
+func (_m *MockIP4Config) GetPropertySearches() ([]string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertySearches")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []string); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockIP4Config_GetPropertySearches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertySearches'
+type MockIP4Config_GetPropertySearches_Call struct {
+	*mock.Call
+}
+
+// GetPropertySearches is a helper method to define mock.On call
+func (_e *MockIP4Config_Expecter) GetPropertySearches() *MockIP4Config_GetPropertySearches_Call {
+	return &MockIP4Config_GetPropertySearches_Call{Call: _e.mock.On("GetPropertySearches")}
+}
+
+func (_c *MockIP4Config_GetPropertySearches_Call) Run(run func()) *MockIP4Config_GetPropertySearches_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertySearches_Call) Return(_a0 []string, _a1 error) *MockIP4Config_GetPropertySearches_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertySearches_Call) RunAndReturn(run func() ([]string, error)) *MockIP4Config_GetPropertySearches_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyWinsServerData provides a mock function with no fields
+func (_m *MockIP4Config) GetPropertyWinsServerData() ([]string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyWinsServerData")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []string); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockIP4Config_GetPropertyWinsServerData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWinsServerData'
+type MockIP4Config_GetPropertyWinsServerData_Call struct {
+	*mock.Call
+}
+
+// GetPropertyWinsServerData is a helper method to define mock.On call
+func (_e *MockIP4Config_Expecter) GetPropertyWinsServerData() *MockIP4Config_GetPropertyWinsServerData_Call {
+	return &MockIP4Config_GetPropertyWinsServerData_Call{Call: _e.mock.On("GetPropertyWinsServerData")}
+}
+
+func (_c *MockIP4Config_GetPropertyWinsServerData_Call) Run(run func()) *MockIP4Config_GetPropertyWinsServerData_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyWinsServerData_Call) Return(_a0 []string, _a1 error) *MockIP4Config_GetPropertyWinsServerData_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockIP4Config_GetPropertyWinsServerData_Call) RunAndReturn(run func() ([]string, error)) *MockIP4Config_GetPropertyWinsServerData_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// MarshalJSON provides a mock function with no fields
+func (_m *MockIP4Config) MarshalJSON() ([]byte, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarshalJSON")
+	}
+
+	var r0 []byte
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]byte, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []byte); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]byte)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockIP4Config_MarshalJSON_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarshalJSON'
+type MockIP4Config_MarshalJSON_Call struct {
+	*mock.Call
+}
+
+// MarshalJSON is a helper method to define mock.On call
+func (_e *MockIP4Config_Expecter) MarshalJSON() *MockIP4Config_MarshalJSON_Call {
+	return &MockIP4Config_MarshalJSON_Call{Call: _e.mock.On("MarshalJSON")}
+}
+
+func (_c *MockIP4Config_MarshalJSON_Call) Run(run func()) *MockIP4Config_MarshalJSON_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockIP4Config_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockIP4Config_MarshalJSON_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockIP4Config_MarshalJSON_Call) RunAndReturn(run func() ([]byte, error)) *MockIP4Config_MarshalJSON_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockIP4Config creates a new instance of MockIP4Config. 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 NewMockIP4Config(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockIP4Config {
+	mock := &MockIP4Config{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_NetworkManager.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_NetworkManager.go
new file mode 100644
index 0000000..e74ffb0
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_NetworkManager.go
@@ -0,0 +1,2349 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package gonetworkmanager
+
+import (
+	gonetworkmanager "github.com/Wifx/gonetworkmanager/v2"
+	dbus "github.com/godbus/dbus/v5"
+
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockNetworkManager is an autogenerated mock type for the NetworkManager type
+type MockNetworkManager struct {
+	mock.Mock
+}
+
+type MockNetworkManager_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockNetworkManager) EXPECT() *MockNetworkManager_Expecter {
+	return &MockNetworkManager_Expecter{mock: &_m.Mock}
+}
+
+// ActivateConnection provides a mock function with given fields: connection, device, specificObject
+func (_m *MockNetworkManager) ActivateConnection(connection gonetworkmanager.Connection, device gonetworkmanager.Device, specificObject *dbus.Object) (gonetworkmanager.ActiveConnection, error) {
+	ret := _m.Called(connection, device, specificObject)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ActivateConnection")
+	}
+
+	var r0 gonetworkmanager.ActiveConnection
+	var r1 error
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.Connection, gonetworkmanager.Device, *dbus.Object) (gonetworkmanager.ActiveConnection, error)); ok {
+		return rf(connection, device, specificObject)
+	}
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.Connection, gonetworkmanager.Device, *dbus.Object) gonetworkmanager.ActiveConnection); ok {
+		r0 = rf(connection, device, specificObject)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.ActiveConnection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(gonetworkmanager.Connection, gonetworkmanager.Device, *dbus.Object) error); ok {
+		r1 = rf(connection, device, specificObject)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_ActivateConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ActivateConnection'
+type MockNetworkManager_ActivateConnection_Call struct {
+	*mock.Call
+}
+
+// ActivateConnection is a helper method to define mock.On call
+//   - connection gonetworkmanager.Connection
+//   - device gonetworkmanager.Device
+//   - specificObject *dbus.Object
+func (_e *MockNetworkManager_Expecter) ActivateConnection(connection interface{}, device interface{}, specificObject interface{}) *MockNetworkManager_ActivateConnection_Call {
+	return &MockNetworkManager_ActivateConnection_Call{Call: _e.mock.On("ActivateConnection", connection, device, specificObject)}
+}
+
+func (_c *MockNetworkManager_ActivateConnection_Call) Run(run func(connection gonetworkmanager.Connection, device gonetworkmanager.Device, specificObject *dbus.Object)) *MockNetworkManager_ActivateConnection_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(gonetworkmanager.Connection), args[1].(gonetworkmanager.Device), args[2].(*dbus.Object))
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_ActivateConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockNetworkManager_ActivateConnection_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_ActivateConnection_Call) RunAndReturn(run func(gonetworkmanager.Connection, gonetworkmanager.Device, *dbus.Object) (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_ActivateConnection_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ActivateWirelessConnection provides a mock function with given fields: connection, device, accessPoint
+func (_m *MockNetworkManager) ActivateWirelessConnection(connection gonetworkmanager.Connection, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error) {
+	ret := _m.Called(connection, device, accessPoint)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ActivateWirelessConnection")
+	}
+
+	var r0 gonetworkmanager.ActiveConnection
+	var r1 error
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.Connection, gonetworkmanager.Device, gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error)); ok {
+		return rf(connection, device, accessPoint)
+	}
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.Connection, gonetworkmanager.Device, gonetworkmanager.AccessPoint) gonetworkmanager.ActiveConnection); ok {
+		r0 = rf(connection, device, accessPoint)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.ActiveConnection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(gonetworkmanager.Connection, gonetworkmanager.Device, gonetworkmanager.AccessPoint) error); ok {
+		r1 = rf(connection, device, accessPoint)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_ActivateWirelessConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ActivateWirelessConnection'
+type MockNetworkManager_ActivateWirelessConnection_Call struct {
+	*mock.Call
+}
+
+// ActivateWirelessConnection is a helper method to define mock.On call
+//   - connection gonetworkmanager.Connection
+//   - device gonetworkmanager.Device
+//   - accessPoint gonetworkmanager.AccessPoint
+func (_e *MockNetworkManager_Expecter) ActivateWirelessConnection(connection interface{}, device interface{}, accessPoint interface{}) *MockNetworkManager_ActivateWirelessConnection_Call {
+	return &MockNetworkManager_ActivateWirelessConnection_Call{Call: _e.mock.On("ActivateWirelessConnection", connection, device, accessPoint)}
+}
+
+func (_c *MockNetworkManager_ActivateWirelessConnection_Call) Run(run func(connection gonetworkmanager.Connection, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint)) *MockNetworkManager_ActivateWirelessConnection_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(gonetworkmanager.Connection), args[1].(gonetworkmanager.Device), args[2].(gonetworkmanager.AccessPoint))
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_ActivateWirelessConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockNetworkManager_ActivateWirelessConnection_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_ActivateWirelessConnection_Call) RunAndReturn(run func(gonetworkmanager.Connection, gonetworkmanager.Device, gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_ActivateWirelessConnection_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// AddAndActivateConnection provides a mock function with given fields: connection, device
+func (_m *MockNetworkManager) AddAndActivateConnection(connection map[string]map[string]interface{}, device gonetworkmanager.Device) (gonetworkmanager.ActiveConnection, error) {
+	ret := _m.Called(connection, device)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AddAndActivateConnection")
+	}
+
+	var r0 gonetworkmanager.ActiveConnection
+	var r1 error
+	if rf, ok := ret.Get(0).(func(map[string]map[string]interface{}, gonetworkmanager.Device) (gonetworkmanager.ActiveConnection, error)); ok {
+		return rf(connection, device)
+	}
+	if rf, ok := ret.Get(0).(func(map[string]map[string]interface{}, gonetworkmanager.Device) gonetworkmanager.ActiveConnection); ok {
+		r0 = rf(connection, device)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.ActiveConnection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(map[string]map[string]interface{}, gonetworkmanager.Device) error); ok {
+		r1 = rf(connection, device)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_AddAndActivateConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAndActivateConnection'
+type MockNetworkManager_AddAndActivateConnection_Call struct {
+	*mock.Call
+}
+
+// AddAndActivateConnection is a helper method to define mock.On call
+//   - connection map[string]map[string]interface{}
+//   - device gonetworkmanager.Device
+func (_e *MockNetworkManager_Expecter) AddAndActivateConnection(connection interface{}, device interface{}) *MockNetworkManager_AddAndActivateConnection_Call {
+	return &MockNetworkManager_AddAndActivateConnection_Call{Call: _e.mock.On("AddAndActivateConnection", connection, device)}
+}
+
+func (_c *MockNetworkManager_AddAndActivateConnection_Call) Run(run func(connection map[string]map[string]interface{}, device gonetworkmanager.Device)) *MockNetworkManager_AddAndActivateConnection_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(map[string]map[string]interface{}), args[1].(gonetworkmanager.Device))
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_AddAndActivateConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockNetworkManager_AddAndActivateConnection_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_AddAndActivateConnection_Call) RunAndReturn(run func(map[string]map[string]interface{}, gonetworkmanager.Device) (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_AddAndActivateConnection_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// AddAndActivateWirelessConnection provides a mock function with given fields: connection, device, accessPoint
+func (_m *MockNetworkManager) AddAndActivateWirelessConnection(connection map[string]map[string]interface{}, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error) {
+	ret := _m.Called(connection, device, accessPoint)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AddAndActivateWirelessConnection")
+	}
+
+	var r0 gonetworkmanager.ActiveConnection
+	var r1 error
+	if rf, ok := ret.Get(0).(func(map[string]map[string]interface{}, gonetworkmanager.Device, gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error)); ok {
+		return rf(connection, device, accessPoint)
+	}
+	if rf, ok := ret.Get(0).(func(map[string]map[string]interface{}, gonetworkmanager.Device, gonetworkmanager.AccessPoint) gonetworkmanager.ActiveConnection); ok {
+		r0 = rf(connection, device, accessPoint)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.ActiveConnection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(map[string]map[string]interface{}, gonetworkmanager.Device, gonetworkmanager.AccessPoint) error); ok {
+		r1 = rf(connection, device, accessPoint)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_AddAndActivateWirelessConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAndActivateWirelessConnection'
+type MockNetworkManager_AddAndActivateWirelessConnection_Call struct {
+	*mock.Call
+}
+
+// AddAndActivateWirelessConnection is a helper method to define mock.On call
+//   - connection map[string]map[string]interface{}
+//   - device gonetworkmanager.Device
+//   - accessPoint gonetworkmanager.AccessPoint
+func (_e *MockNetworkManager_Expecter) AddAndActivateWirelessConnection(connection interface{}, device interface{}, accessPoint interface{}) *MockNetworkManager_AddAndActivateWirelessConnection_Call {
+	return &MockNetworkManager_AddAndActivateWirelessConnection_Call{Call: _e.mock.On("AddAndActivateWirelessConnection", connection, device, accessPoint)}
+}
+
+func (_c *MockNetworkManager_AddAndActivateWirelessConnection_Call) Run(run func(connection map[string]map[string]interface{}, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint)) *MockNetworkManager_AddAndActivateWirelessConnection_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(map[string]map[string]interface{}), args[1].(gonetworkmanager.Device), args[2].(gonetworkmanager.AccessPoint))
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_AddAndActivateWirelessConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockNetworkManager_AddAndActivateWirelessConnection_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_AddAndActivateWirelessConnection_Call) RunAndReturn(run func(map[string]map[string]interface{}, gonetworkmanager.Device, gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_AddAndActivateWirelessConnection_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CheckConnectivity provides a mock function with no fields
+func (_m *MockNetworkManager) CheckConnectivity() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for CheckConnectivity")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockNetworkManager_CheckConnectivity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckConnectivity'
+type MockNetworkManager_CheckConnectivity_Call struct {
+	*mock.Call
+}
+
+// CheckConnectivity is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) CheckConnectivity() *MockNetworkManager_CheckConnectivity_Call {
+	return &MockNetworkManager_CheckConnectivity_Call{Call: _e.mock.On("CheckConnectivity")}
+}
+
+func (_c *MockNetworkManager_CheckConnectivity_Call) Run(run func()) *MockNetworkManager_CheckConnectivity_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_CheckConnectivity_Call) Return(_a0 error) *MockNetworkManager_CheckConnectivity_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockNetworkManager_CheckConnectivity_Call) RunAndReturn(run func() error) *MockNetworkManager_CheckConnectivity_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CheckpointAdjustRollbackTimeout provides a mock function with given fields: checkpoint, addTimeout
+func (_m *MockNetworkManager) CheckpointAdjustRollbackTimeout(checkpoint gonetworkmanager.Checkpoint, addTimeout uint32) error {
+	ret := _m.Called(checkpoint, addTimeout)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CheckpointAdjustRollbackTimeout")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.Checkpoint, uint32) error); ok {
+		r0 = rf(checkpoint, addTimeout)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockNetworkManager_CheckpointAdjustRollbackTimeout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckpointAdjustRollbackTimeout'
+type MockNetworkManager_CheckpointAdjustRollbackTimeout_Call struct {
+	*mock.Call
+}
+
+// CheckpointAdjustRollbackTimeout is a helper method to define mock.On call
+//   - checkpoint gonetworkmanager.Checkpoint
+//   - addTimeout uint32
+func (_e *MockNetworkManager_Expecter) CheckpointAdjustRollbackTimeout(checkpoint interface{}, addTimeout interface{}) *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call {
+	return &MockNetworkManager_CheckpointAdjustRollbackTimeout_Call{Call: _e.mock.On("CheckpointAdjustRollbackTimeout", checkpoint, addTimeout)}
+}
+
+func (_c *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call) Run(run func(checkpoint gonetworkmanager.Checkpoint, addTimeout uint32)) *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(gonetworkmanager.Checkpoint), args[1].(uint32))
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call) Return(_a0 error) *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call) RunAndReturn(run func(gonetworkmanager.Checkpoint, uint32) error) *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CheckpointCreate provides a mock function with given fields: devices, rollbackTimeout, flags
+func (_m *MockNetworkManager) CheckpointCreate(devices []gonetworkmanager.Device, rollbackTimeout uint32, flags uint32) (gonetworkmanager.Checkpoint, error) {
+	ret := _m.Called(devices, rollbackTimeout, flags)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CheckpointCreate")
+	}
+
+	var r0 gonetworkmanager.Checkpoint
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]gonetworkmanager.Device, uint32, uint32) (gonetworkmanager.Checkpoint, error)); ok {
+		return rf(devices, rollbackTimeout, flags)
+	}
+	if rf, ok := ret.Get(0).(func([]gonetworkmanager.Device, uint32, uint32) gonetworkmanager.Checkpoint); ok {
+		r0 = rf(devices, rollbackTimeout, flags)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.Checkpoint)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func([]gonetworkmanager.Device, uint32, uint32) error); ok {
+		r1 = rf(devices, rollbackTimeout, flags)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_CheckpointCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckpointCreate'
+type MockNetworkManager_CheckpointCreate_Call struct {
+	*mock.Call
+}
+
+// CheckpointCreate is a helper method to define mock.On call
+//   - devices []gonetworkmanager.Device
+//   - rollbackTimeout uint32
+//   - flags uint32
+func (_e *MockNetworkManager_Expecter) CheckpointCreate(devices interface{}, rollbackTimeout interface{}, flags interface{}) *MockNetworkManager_CheckpointCreate_Call {
+	return &MockNetworkManager_CheckpointCreate_Call{Call: _e.mock.On("CheckpointCreate", devices, rollbackTimeout, flags)}
+}
+
+func (_c *MockNetworkManager_CheckpointCreate_Call) Run(run func(devices []gonetworkmanager.Device, rollbackTimeout uint32, flags uint32)) *MockNetworkManager_CheckpointCreate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].([]gonetworkmanager.Device), args[1].(uint32), args[2].(uint32))
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_CheckpointCreate_Call) Return(_a0 gonetworkmanager.Checkpoint, _a1 error) *MockNetworkManager_CheckpointCreate_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_CheckpointCreate_Call) RunAndReturn(run func([]gonetworkmanager.Device, uint32, uint32) (gonetworkmanager.Checkpoint, error)) *MockNetworkManager_CheckpointCreate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CheckpointDestroy provides a mock function with given fields: checkpoint
+func (_m *MockNetworkManager) CheckpointDestroy(checkpoint gonetworkmanager.Checkpoint) error {
+	ret := _m.Called(checkpoint)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CheckpointDestroy")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.Checkpoint) error); ok {
+		r0 = rf(checkpoint)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockNetworkManager_CheckpointDestroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckpointDestroy'
+type MockNetworkManager_CheckpointDestroy_Call struct {
+	*mock.Call
+}
+
+// CheckpointDestroy is a helper method to define mock.On call
+//   - checkpoint gonetworkmanager.Checkpoint
+func (_e *MockNetworkManager_Expecter) CheckpointDestroy(checkpoint interface{}) *MockNetworkManager_CheckpointDestroy_Call {
+	return &MockNetworkManager_CheckpointDestroy_Call{Call: _e.mock.On("CheckpointDestroy", checkpoint)}
+}
+
+func (_c *MockNetworkManager_CheckpointDestroy_Call) Run(run func(checkpoint gonetworkmanager.Checkpoint)) *MockNetworkManager_CheckpointDestroy_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(gonetworkmanager.Checkpoint))
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_CheckpointDestroy_Call) Return(_a0 error) *MockNetworkManager_CheckpointDestroy_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockNetworkManager_CheckpointDestroy_Call) RunAndReturn(run func(gonetworkmanager.Checkpoint) error) *MockNetworkManager_CheckpointDestroy_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CheckpointRollback provides a mock function with given fields: checkpoint
+func (_m *MockNetworkManager) CheckpointRollback(checkpoint gonetworkmanager.Checkpoint) (map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult, error) {
+	ret := _m.Called(checkpoint)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CheckpointRollback")
+	}
+
+	var r0 map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult
+	var r1 error
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.Checkpoint) (map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult, error)); ok {
+		return rf(checkpoint)
+	}
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.Checkpoint) map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult); ok {
+		r0 = rf(checkpoint)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(gonetworkmanager.Checkpoint) error); ok {
+		r1 = rf(checkpoint)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_CheckpointRollback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckpointRollback'
+type MockNetworkManager_CheckpointRollback_Call struct {
+	*mock.Call
+}
+
+// CheckpointRollback is a helper method to define mock.On call
+//   - checkpoint gonetworkmanager.Checkpoint
+func (_e *MockNetworkManager_Expecter) CheckpointRollback(checkpoint interface{}) *MockNetworkManager_CheckpointRollback_Call {
+	return &MockNetworkManager_CheckpointRollback_Call{Call: _e.mock.On("CheckpointRollback", checkpoint)}
+}
+
+func (_c *MockNetworkManager_CheckpointRollback_Call) Run(run func(checkpoint gonetworkmanager.Checkpoint)) *MockNetworkManager_CheckpointRollback_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(gonetworkmanager.Checkpoint))
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_CheckpointRollback_Call) Return(result map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult, err error) *MockNetworkManager_CheckpointRollback_Call {
+	_c.Call.Return(result, err)
+	return _c
+}
+
+func (_c *MockNetworkManager_CheckpointRollback_Call) RunAndReturn(run func(gonetworkmanager.Checkpoint) (map[dbus.ObjectPath]gonetworkmanager.NmRollbackResult, error)) *MockNetworkManager_CheckpointRollback_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// DeactivateConnection provides a mock function with given fields: connection
+func (_m *MockNetworkManager) DeactivateConnection(connection gonetworkmanager.ActiveConnection) error {
+	ret := _m.Called(connection)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeactivateConnection")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.ActiveConnection) error); ok {
+		r0 = rf(connection)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockNetworkManager_DeactivateConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeactivateConnection'
+type MockNetworkManager_DeactivateConnection_Call struct {
+	*mock.Call
+}
+
+// DeactivateConnection is a helper method to define mock.On call
+//   - connection gonetworkmanager.ActiveConnection
+func (_e *MockNetworkManager_Expecter) DeactivateConnection(connection interface{}) *MockNetworkManager_DeactivateConnection_Call {
+	return &MockNetworkManager_DeactivateConnection_Call{Call: _e.mock.On("DeactivateConnection", connection)}
+}
+
+func (_c *MockNetworkManager_DeactivateConnection_Call) Run(run func(connection gonetworkmanager.ActiveConnection)) *MockNetworkManager_DeactivateConnection_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(gonetworkmanager.ActiveConnection))
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_DeactivateConnection_Call) Return(_a0 error) *MockNetworkManager_DeactivateConnection_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockNetworkManager_DeactivateConnection_Call) RunAndReturn(run func(gonetworkmanager.ActiveConnection) error) *MockNetworkManager_DeactivateConnection_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Enable provides a mock function with given fields: enableNDisable
+func (_m *MockNetworkManager) Enable(enableNDisable bool) error {
+	ret := _m.Called(enableNDisable)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Enable")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(bool) error); ok {
+		r0 = rf(enableNDisable)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockNetworkManager_Enable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Enable'
+type MockNetworkManager_Enable_Call struct {
+	*mock.Call
+}
+
+// Enable is a helper method to define mock.On call
+//   - enableNDisable bool
+func (_e *MockNetworkManager_Expecter) Enable(enableNDisable interface{}) *MockNetworkManager_Enable_Call {
+	return &MockNetworkManager_Enable_Call{Call: _e.mock.On("Enable", enableNDisable)}
+}
+
+func (_c *MockNetworkManager_Enable_Call) Run(run func(enableNDisable bool)) *MockNetworkManager_Enable_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(bool))
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_Enable_Call) Return(_a0 error) *MockNetworkManager_Enable_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockNetworkManager_Enable_Call) RunAndReturn(run func(bool) error) *MockNetworkManager_Enable_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetAllDevices provides a mock function with no fields
+func (_m *MockNetworkManager) GetAllDevices() ([]gonetworkmanager.Device, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetAllDevices")
+	}
+
+	var r0 []gonetworkmanager.Device
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.Device)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_GetAllDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllDevices'
+type MockNetworkManager_GetAllDevices_Call struct {
+	*mock.Call
+}
+
+// GetAllDevices is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetAllDevices() *MockNetworkManager_GetAllDevices_Call {
+	return &MockNetworkManager_GetAllDevices_Call{Call: _e.mock.On("GetAllDevices")}
+}
+
+func (_c *MockNetworkManager_GetAllDevices_Call) Run(run func()) *MockNetworkManager_GetAllDevices_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetAllDevices_Call) Return(_a0 []gonetworkmanager.Device, _a1 error) *MockNetworkManager_GetAllDevices_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetAllDevices_Call) RunAndReturn(run func() ([]gonetworkmanager.Device, error)) *MockNetworkManager_GetAllDevices_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetDeviceByIpIface provides a mock function with given fields: interfaceId
+func (_m *MockNetworkManager) GetDeviceByIpIface(interfaceId string) (gonetworkmanager.Device, error) {
+	ret := _m.Called(interfaceId)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetDeviceByIpIface")
+	}
+
+	var r0 gonetworkmanager.Device
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (gonetworkmanager.Device, error)); ok {
+		return rf(interfaceId)
+	}
+	if rf, ok := ret.Get(0).(func(string) gonetworkmanager.Device); ok {
+		r0 = rf(interfaceId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.Device)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(interfaceId)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_GetDeviceByIpIface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDeviceByIpIface'
+type MockNetworkManager_GetDeviceByIpIface_Call struct {
+	*mock.Call
+}
+
+// GetDeviceByIpIface is a helper method to define mock.On call
+//   - interfaceId string
+func (_e *MockNetworkManager_Expecter) GetDeviceByIpIface(interfaceId interface{}) *MockNetworkManager_GetDeviceByIpIface_Call {
+	return &MockNetworkManager_GetDeviceByIpIface_Call{Call: _e.mock.On("GetDeviceByIpIface", interfaceId)}
+}
+
+func (_c *MockNetworkManager_GetDeviceByIpIface_Call) Run(run func(interfaceId string)) *MockNetworkManager_GetDeviceByIpIface_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetDeviceByIpIface_Call) Return(_a0 gonetworkmanager.Device, _a1 error) *MockNetworkManager_GetDeviceByIpIface_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetDeviceByIpIface_Call) RunAndReturn(run func(string) (gonetworkmanager.Device, error)) *MockNetworkManager_GetDeviceByIpIface_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetDevices provides a mock function with no fields
+func (_m *MockNetworkManager) GetDevices() ([]gonetworkmanager.Device, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetDevices")
+	}
+
+	var r0 []gonetworkmanager.Device
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.Device)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_GetDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDevices'
+type MockNetworkManager_GetDevices_Call struct {
+	*mock.Call
+}
+
+// GetDevices is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetDevices() *MockNetworkManager_GetDevices_Call {
+	return &MockNetworkManager_GetDevices_Call{Call: _e.mock.On("GetDevices")}
+}
+
+func (_c *MockNetworkManager_GetDevices_Call) Run(run func()) *MockNetworkManager_GetDevices_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetDevices_Call) Return(_a0 []gonetworkmanager.Device, _a1 error) *MockNetworkManager_GetDevices_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetDevices_Call) RunAndReturn(run func() ([]gonetworkmanager.Device, error)) *MockNetworkManager_GetDevices_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyActivatingConnection provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyActivatingConnection() (gonetworkmanager.ActiveConnection, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyActivatingConnection")
+	}
+
+	var r0 gonetworkmanager.ActiveConnection
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.ActiveConnection, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.ActiveConnection); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.ActiveConnection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_GetPropertyActivatingConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyActivatingConnection'
+type MockNetworkManager_GetPropertyActivatingConnection_Call struct {
+	*mock.Call
+}
+
+// GetPropertyActivatingConnection is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyActivatingConnection() *MockNetworkManager_GetPropertyActivatingConnection_Call {
+	return &MockNetworkManager_GetPropertyActivatingConnection_Call{Call: _e.mock.On("GetPropertyActivatingConnection")}
+}
+
+func (_c *MockNetworkManager_GetPropertyActivatingConnection_Call) Run(run func()) *MockNetworkManager_GetPropertyActivatingConnection_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyActivatingConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockNetworkManager_GetPropertyActivatingConnection_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyActivatingConnection_Call) RunAndReturn(run func() (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_GetPropertyActivatingConnection_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyActiveConnections provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyActiveConnections() ([]gonetworkmanager.ActiveConnection, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyActiveConnections")
+	}
+
+	var r0 []gonetworkmanager.ActiveConnection
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.ActiveConnection, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.ActiveConnection); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.ActiveConnection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_GetPropertyActiveConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyActiveConnections'
+type MockNetworkManager_GetPropertyActiveConnections_Call struct {
+	*mock.Call
+}
+
+// GetPropertyActiveConnections is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyActiveConnections() *MockNetworkManager_GetPropertyActiveConnections_Call {
+	return &MockNetworkManager_GetPropertyActiveConnections_Call{Call: _e.mock.On("GetPropertyActiveConnections")}
+}
+
+func (_c *MockNetworkManager_GetPropertyActiveConnections_Call) Run(run func()) *MockNetworkManager_GetPropertyActiveConnections_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyActiveConnections_Call) Return(_a0 []gonetworkmanager.ActiveConnection, _a1 error) *MockNetworkManager_GetPropertyActiveConnections_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyActiveConnections_Call) RunAndReturn(run func() ([]gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_GetPropertyActiveConnections_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyAllDevices provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyAllDevices() ([]gonetworkmanager.Device, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyAllDevices")
+	}
+
+	var r0 []gonetworkmanager.Device
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.Device)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_GetPropertyAllDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyAllDevices'
+type MockNetworkManager_GetPropertyAllDevices_Call struct {
+	*mock.Call
+}
+
+// GetPropertyAllDevices is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyAllDevices() *MockNetworkManager_GetPropertyAllDevices_Call {
+	return &MockNetworkManager_GetPropertyAllDevices_Call{Call: _e.mock.On("GetPropertyAllDevices")}
+}
+
+func (_c *MockNetworkManager_GetPropertyAllDevices_Call) Run(run func()) *MockNetworkManager_GetPropertyAllDevices_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyAllDevices_Call) Return(_a0 []gonetworkmanager.Device, _a1 error) *MockNetworkManager_GetPropertyAllDevices_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyAllDevices_Call) RunAndReturn(run func() ([]gonetworkmanager.Device, error)) *MockNetworkManager_GetPropertyAllDevices_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyCapabilities provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyCapabilities() ([]gonetworkmanager.NmCapability, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyCapabilities")
+	}
+
+	var r0 []gonetworkmanager.NmCapability
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.NmCapability, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.NmCapability); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.NmCapability)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_GetPropertyCapabilities_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyCapabilities'
+type MockNetworkManager_GetPropertyCapabilities_Call struct {
+	*mock.Call
+}
+
+// GetPropertyCapabilities is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyCapabilities() *MockNetworkManager_GetPropertyCapabilities_Call {
+	return &MockNetworkManager_GetPropertyCapabilities_Call{Call: _e.mock.On("GetPropertyCapabilities")}
+}
+
+func (_c *MockNetworkManager_GetPropertyCapabilities_Call) Run(run func()) *MockNetworkManager_GetPropertyCapabilities_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyCapabilities_Call) Return(_a0 []gonetworkmanager.NmCapability, _a1 error) *MockNetworkManager_GetPropertyCapabilities_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyCapabilities_Call) RunAndReturn(run func() ([]gonetworkmanager.NmCapability, error)) *MockNetworkManager_GetPropertyCapabilities_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyCheckpoints provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyCheckpoints() ([]gonetworkmanager.Checkpoint, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyCheckpoints")
+	}
+
+	var r0 []gonetworkmanager.Checkpoint
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Checkpoint, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.Checkpoint); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.Checkpoint)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_GetPropertyCheckpoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyCheckpoints'
+type MockNetworkManager_GetPropertyCheckpoints_Call struct {
+	*mock.Call
+}
+
+// GetPropertyCheckpoints is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyCheckpoints() *MockNetworkManager_GetPropertyCheckpoints_Call {
+	return &MockNetworkManager_GetPropertyCheckpoints_Call{Call: _e.mock.On("GetPropertyCheckpoints")}
+}
+
+func (_c *MockNetworkManager_GetPropertyCheckpoints_Call) Run(run func()) *MockNetworkManager_GetPropertyCheckpoints_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyCheckpoints_Call) Return(_a0 []gonetworkmanager.Checkpoint, _a1 error) *MockNetworkManager_GetPropertyCheckpoints_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyCheckpoints_Call) RunAndReturn(run func() ([]gonetworkmanager.Checkpoint, error)) *MockNetworkManager_GetPropertyCheckpoints_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyConnectivity provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyConnectivity() (gonetworkmanager.NmConnectivity, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyConnectivity")
+	}
+
+	var r0 gonetworkmanager.NmConnectivity
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmConnectivity, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.NmConnectivity); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(gonetworkmanager.NmConnectivity)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_GetPropertyConnectivity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyConnectivity'
+type MockNetworkManager_GetPropertyConnectivity_Call struct {
+	*mock.Call
+}
+
+// GetPropertyConnectivity is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyConnectivity() *MockNetworkManager_GetPropertyConnectivity_Call {
+	return &MockNetworkManager_GetPropertyConnectivity_Call{Call: _e.mock.On("GetPropertyConnectivity")}
+}
+
+func (_c *MockNetworkManager_GetPropertyConnectivity_Call) Run(run func()) *MockNetworkManager_GetPropertyConnectivity_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyConnectivity_Call) Return(_a0 gonetworkmanager.NmConnectivity, _a1 error) *MockNetworkManager_GetPropertyConnectivity_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyConnectivity_Call) RunAndReturn(run func() (gonetworkmanager.NmConnectivity, error)) *MockNetworkManager_GetPropertyConnectivity_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyConnectivityCheckAvailable provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyConnectivityCheckAvailable() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyConnectivityCheckAvailable")
+	}
+
+	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
+}
+
+// MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyConnectivityCheckAvailable'
+type MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call struct {
+	*mock.Call
+}
+
+// GetPropertyConnectivityCheckAvailable is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyConnectivityCheckAvailable() *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call {
+	return &MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call{Call: _e.mock.On("GetPropertyConnectivityCheckAvailable")}
+}
+
+func (_c *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call) Run(run func()) *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyConnectivityCheckAvailable_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyConnectivityCheckEnabled provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyConnectivityCheckEnabled() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyConnectivityCheckEnabled")
+	}
+
+	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
+}
+
+// MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyConnectivityCheckEnabled'
+type MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call struct {
+	*mock.Call
+}
+
+// GetPropertyConnectivityCheckEnabled is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyConnectivityCheckEnabled() *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call {
+	return &MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call{Call: _e.mock.On("GetPropertyConnectivityCheckEnabled")}
+}
+
+func (_c *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyConnectivityCheckEnabled_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyDevices provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyDevices() ([]gonetworkmanager.Device, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyDevices")
+	}
+
+	var r0 []gonetworkmanager.Device
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.Device)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_GetPropertyDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyDevices'
+type MockNetworkManager_GetPropertyDevices_Call struct {
+	*mock.Call
+}
+
+// GetPropertyDevices is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyDevices() *MockNetworkManager_GetPropertyDevices_Call {
+	return &MockNetworkManager_GetPropertyDevices_Call{Call: _e.mock.On("GetPropertyDevices")}
+}
+
+func (_c *MockNetworkManager_GetPropertyDevices_Call) Run(run func()) *MockNetworkManager_GetPropertyDevices_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyDevices_Call) Return(_a0 []gonetworkmanager.Device, _a1 error) *MockNetworkManager_GetPropertyDevices_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyDevices_Call) RunAndReturn(run func() ([]gonetworkmanager.Device, error)) *MockNetworkManager_GetPropertyDevices_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyMetered provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyMetered() (gonetworkmanager.NmMetered, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyMetered")
+	}
+
+	var r0 gonetworkmanager.NmMetered
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmMetered, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.NmMetered); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(gonetworkmanager.NmMetered)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_GetPropertyMetered_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyMetered'
+type MockNetworkManager_GetPropertyMetered_Call struct {
+	*mock.Call
+}
+
+// GetPropertyMetered is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyMetered() *MockNetworkManager_GetPropertyMetered_Call {
+	return &MockNetworkManager_GetPropertyMetered_Call{Call: _e.mock.On("GetPropertyMetered")}
+}
+
+func (_c *MockNetworkManager_GetPropertyMetered_Call) Run(run func()) *MockNetworkManager_GetPropertyMetered_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyMetered_Call) Return(_a0 gonetworkmanager.NmMetered, _a1 error) *MockNetworkManager_GetPropertyMetered_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyMetered_Call) RunAndReturn(run func() (gonetworkmanager.NmMetered, error)) *MockNetworkManager_GetPropertyMetered_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyNetworkingEnabled provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyNetworkingEnabled() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyNetworkingEnabled")
+	}
+
+	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
+}
+
+// MockNetworkManager_GetPropertyNetworkingEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyNetworkingEnabled'
+type MockNetworkManager_GetPropertyNetworkingEnabled_Call struct {
+	*mock.Call
+}
+
+// GetPropertyNetworkingEnabled is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyNetworkingEnabled() *MockNetworkManager_GetPropertyNetworkingEnabled_Call {
+	return &MockNetworkManager_GetPropertyNetworkingEnabled_Call{Call: _e.mock.On("GetPropertyNetworkingEnabled")}
+}
+
+func (_c *MockNetworkManager_GetPropertyNetworkingEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyNetworkingEnabled_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyNetworkingEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyNetworkingEnabled_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyNetworkingEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyNetworkingEnabled_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyPrimaryConnection provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyPrimaryConnection() (gonetworkmanager.ActiveConnection, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyPrimaryConnection")
+	}
+
+	var r0 gonetworkmanager.ActiveConnection
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.ActiveConnection, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.ActiveConnection); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.ActiveConnection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_GetPropertyPrimaryConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyPrimaryConnection'
+type MockNetworkManager_GetPropertyPrimaryConnection_Call struct {
+	*mock.Call
+}
+
+// GetPropertyPrimaryConnection is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyPrimaryConnection() *MockNetworkManager_GetPropertyPrimaryConnection_Call {
+	return &MockNetworkManager_GetPropertyPrimaryConnection_Call{Call: _e.mock.On("GetPropertyPrimaryConnection")}
+}
+
+func (_c *MockNetworkManager_GetPropertyPrimaryConnection_Call) Run(run func()) *MockNetworkManager_GetPropertyPrimaryConnection_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyPrimaryConnection_Call) Return(_a0 gonetworkmanager.ActiveConnection, _a1 error) *MockNetworkManager_GetPropertyPrimaryConnection_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyPrimaryConnection_Call) RunAndReturn(run func() (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_GetPropertyPrimaryConnection_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyPrimaryConnectionType provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyPrimaryConnectionType() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyPrimaryConnectionType")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_GetPropertyPrimaryConnectionType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyPrimaryConnectionType'
+type MockNetworkManager_GetPropertyPrimaryConnectionType_Call struct {
+	*mock.Call
+}
+
+// GetPropertyPrimaryConnectionType is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyPrimaryConnectionType() *MockNetworkManager_GetPropertyPrimaryConnectionType_Call {
+	return &MockNetworkManager_GetPropertyPrimaryConnectionType_Call{Call: _e.mock.On("GetPropertyPrimaryConnectionType")}
+}
+
+func (_c *MockNetworkManager_GetPropertyPrimaryConnectionType_Call) Run(run func()) *MockNetworkManager_GetPropertyPrimaryConnectionType_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyPrimaryConnectionType_Call) Return(_a0 string, _a1 error) *MockNetworkManager_GetPropertyPrimaryConnectionType_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyPrimaryConnectionType_Call) RunAndReturn(run func() (string, error)) *MockNetworkManager_GetPropertyPrimaryConnectionType_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyStartup provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyStartup() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyStartup")
+	}
+
+	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
+}
+
+// MockNetworkManager_GetPropertyStartup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyStartup'
+type MockNetworkManager_GetPropertyStartup_Call struct {
+	*mock.Call
+}
+
+// GetPropertyStartup is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyStartup() *MockNetworkManager_GetPropertyStartup_Call {
+	return &MockNetworkManager_GetPropertyStartup_Call{Call: _e.mock.On("GetPropertyStartup")}
+}
+
+func (_c *MockNetworkManager_GetPropertyStartup_Call) Run(run func()) *MockNetworkManager_GetPropertyStartup_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyStartup_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyStartup_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyStartup_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyStartup_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyState provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyState() (gonetworkmanager.NmState, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyState")
+	}
+
+	var r0 gonetworkmanager.NmState
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmState, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.NmState); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(gonetworkmanager.NmState)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_GetPropertyState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyState'
+type MockNetworkManager_GetPropertyState_Call struct {
+	*mock.Call
+}
+
+// GetPropertyState is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyState() *MockNetworkManager_GetPropertyState_Call {
+	return &MockNetworkManager_GetPropertyState_Call{Call: _e.mock.On("GetPropertyState")}
+}
+
+func (_c *MockNetworkManager_GetPropertyState_Call) Run(run func()) *MockNetworkManager_GetPropertyState_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyState_Call) Return(_a0 gonetworkmanager.NmState, _a1 error) *MockNetworkManager_GetPropertyState_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyState_Call) RunAndReturn(run func() (gonetworkmanager.NmState, error)) *MockNetworkManager_GetPropertyState_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyVersion provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyVersion() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyVersion")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_GetPropertyVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyVersion'
+type MockNetworkManager_GetPropertyVersion_Call struct {
+	*mock.Call
+}
+
+// GetPropertyVersion is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyVersion() *MockNetworkManager_GetPropertyVersion_Call {
+	return &MockNetworkManager_GetPropertyVersion_Call{Call: _e.mock.On("GetPropertyVersion")}
+}
+
+func (_c *MockNetworkManager_GetPropertyVersion_Call) Run(run func()) *MockNetworkManager_GetPropertyVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyVersion_Call) Return(_a0 string, _a1 error) *MockNetworkManager_GetPropertyVersion_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyVersion_Call) RunAndReturn(run func() (string, error)) *MockNetworkManager_GetPropertyVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyWimaxEnabled provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyWimaxEnabled() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyWimaxEnabled")
+	}
+
+	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
+}
+
+// MockNetworkManager_GetPropertyWimaxEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWimaxEnabled'
+type MockNetworkManager_GetPropertyWimaxEnabled_Call struct {
+	*mock.Call
+}
+
+// GetPropertyWimaxEnabled is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyWimaxEnabled() *MockNetworkManager_GetPropertyWimaxEnabled_Call {
+	return &MockNetworkManager_GetPropertyWimaxEnabled_Call{Call: _e.mock.On("GetPropertyWimaxEnabled")}
+}
+
+func (_c *MockNetworkManager_GetPropertyWimaxEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWimaxEnabled_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyWimaxEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyWimaxEnabled_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyWimaxEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWimaxEnabled_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyWimaxHardwareEnabled provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyWimaxHardwareEnabled() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyWimaxHardwareEnabled")
+	}
+
+	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
+}
+
+// MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWimaxHardwareEnabled'
+type MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call struct {
+	*mock.Call
+}
+
+// GetPropertyWimaxHardwareEnabled is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyWimaxHardwareEnabled() *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call {
+	return &MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call{Call: _e.mock.On("GetPropertyWimaxHardwareEnabled")}
+}
+
+func (_c *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWimaxHardwareEnabled_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyWirelessEnabled provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyWirelessEnabled() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyWirelessEnabled")
+	}
+
+	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
+}
+
+// MockNetworkManager_GetPropertyWirelessEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWirelessEnabled'
+type MockNetworkManager_GetPropertyWirelessEnabled_Call struct {
+	*mock.Call
+}
+
+// GetPropertyWirelessEnabled is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyWirelessEnabled() *MockNetworkManager_GetPropertyWirelessEnabled_Call {
+	return &MockNetworkManager_GetPropertyWirelessEnabled_Call{Call: _e.mock.On("GetPropertyWirelessEnabled")}
+}
+
+func (_c *MockNetworkManager_GetPropertyWirelessEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWirelessEnabled_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyWirelessEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyWirelessEnabled_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyWirelessEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWirelessEnabled_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyWirelessHardwareEnabled provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyWirelessHardwareEnabled() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyWirelessHardwareEnabled")
+	}
+
+	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
+}
+
+// MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWirelessHardwareEnabled'
+type MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call struct {
+	*mock.Call
+}
+
+// GetPropertyWirelessHardwareEnabled is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyWirelessHardwareEnabled() *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call {
+	return &MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call{Call: _e.mock.On("GetPropertyWirelessHardwareEnabled")}
+}
+
+func (_c *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWirelessHardwareEnabled_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyWwanEnabled provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyWwanEnabled() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyWwanEnabled")
+	}
+
+	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
+}
+
+// MockNetworkManager_GetPropertyWwanEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWwanEnabled'
+type MockNetworkManager_GetPropertyWwanEnabled_Call struct {
+	*mock.Call
+}
+
+// GetPropertyWwanEnabled is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyWwanEnabled() *MockNetworkManager_GetPropertyWwanEnabled_Call {
+	return &MockNetworkManager_GetPropertyWwanEnabled_Call{Call: _e.mock.On("GetPropertyWwanEnabled")}
+}
+
+func (_c *MockNetworkManager_GetPropertyWwanEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWwanEnabled_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyWwanEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyWwanEnabled_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyWwanEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWwanEnabled_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyWwanHardwareEnabled provides a mock function with no fields
+func (_m *MockNetworkManager) GetPropertyWwanHardwareEnabled() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyWwanHardwareEnabled")
+	}
+
+	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
+}
+
+// MockNetworkManager_GetPropertyWwanHardwareEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyWwanHardwareEnabled'
+type MockNetworkManager_GetPropertyWwanHardwareEnabled_Call struct {
+	*mock.Call
+}
+
+// GetPropertyWwanHardwareEnabled is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) GetPropertyWwanHardwareEnabled() *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call {
+	return &MockNetworkManager_GetPropertyWwanHardwareEnabled_Call{Call: _e.mock.On("GetPropertyWwanHardwareEnabled")}
+}
+
+func (_c *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call) Run(run func()) *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call) Return(_a0 bool, _a1 error) *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call) RunAndReturn(run func() (bool, error)) *MockNetworkManager_GetPropertyWwanHardwareEnabled_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// MarshalJSON provides a mock function with no fields
+func (_m *MockNetworkManager) MarshalJSON() ([]byte, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for MarshalJSON")
+	}
+
+	var r0 []byte
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]byte, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []byte); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]byte)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_MarshalJSON_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarshalJSON'
+type MockNetworkManager_MarshalJSON_Call struct {
+	*mock.Call
+}
+
+// MarshalJSON is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) MarshalJSON() *MockNetworkManager_MarshalJSON_Call {
+	return &MockNetworkManager_MarshalJSON_Call{Call: _e.mock.On("MarshalJSON")}
+}
+
+func (_c *MockNetworkManager_MarshalJSON_Call) Run(run func()) *MockNetworkManager_MarshalJSON_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockNetworkManager_MarshalJSON_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_MarshalJSON_Call) RunAndReturn(run func() ([]byte, error)) *MockNetworkManager_MarshalJSON_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Reload provides a mock function with given fields: flags
+func (_m *MockNetworkManager) Reload(flags uint32) error {
+	ret := _m.Called(flags)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Reload")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(uint32) error); ok {
+		r0 = rf(flags)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockNetworkManager_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
+type MockNetworkManager_Reload_Call struct {
+	*mock.Call
+}
+
+// Reload is a helper method to define mock.On call
+//   - flags uint32
+func (_e *MockNetworkManager_Expecter) Reload(flags interface{}) *MockNetworkManager_Reload_Call {
+	return &MockNetworkManager_Reload_Call{Call: _e.mock.On("Reload", flags)}
+}
+
+func (_c *MockNetworkManager_Reload_Call) Run(run func(flags uint32)) *MockNetworkManager_Reload_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(uint32))
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_Reload_Call) Return(_a0 error) *MockNetworkManager_Reload_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockNetworkManager_Reload_Call) RunAndReturn(run func(uint32) error) *MockNetworkManager_Reload_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetPropertyWirelessEnabled provides a mock function with given fields: _a0
+func (_m *MockNetworkManager) SetPropertyWirelessEnabled(_a0 bool) error {
+	ret := _m.Called(_a0)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetPropertyWirelessEnabled")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(bool) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockNetworkManager_SetPropertyWirelessEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPropertyWirelessEnabled'
+type MockNetworkManager_SetPropertyWirelessEnabled_Call struct {
+	*mock.Call
+}
+
+// SetPropertyWirelessEnabled is a helper method to define mock.On call
+//   - _a0 bool
+func (_e *MockNetworkManager_Expecter) SetPropertyWirelessEnabled(_a0 interface{}) *MockNetworkManager_SetPropertyWirelessEnabled_Call {
+	return &MockNetworkManager_SetPropertyWirelessEnabled_Call{Call: _e.mock.On("SetPropertyWirelessEnabled", _a0)}
+}
+
+func (_c *MockNetworkManager_SetPropertyWirelessEnabled_Call) Run(run func(_a0 bool)) *MockNetworkManager_SetPropertyWirelessEnabled_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(bool))
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_SetPropertyWirelessEnabled_Call) Return(_a0 error) *MockNetworkManager_SetPropertyWirelessEnabled_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockNetworkManager_SetPropertyWirelessEnabled_Call) RunAndReturn(run func(bool) error) *MockNetworkManager_SetPropertyWirelessEnabled_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Sleep provides a mock function with given fields: sleepNWake
+func (_m *MockNetworkManager) Sleep(sleepNWake bool) error {
+	ret := _m.Called(sleepNWake)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Sleep")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(bool) error); ok {
+		r0 = rf(sleepNWake)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockNetworkManager_Sleep_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sleep'
+type MockNetworkManager_Sleep_Call struct {
+	*mock.Call
+}
+
+// Sleep is a helper method to define mock.On call
+//   - sleepNWake bool
+func (_e *MockNetworkManager_Expecter) Sleep(sleepNWake interface{}) *MockNetworkManager_Sleep_Call {
+	return &MockNetworkManager_Sleep_Call{Call: _e.mock.On("Sleep", sleepNWake)}
+}
+
+func (_c *MockNetworkManager_Sleep_Call) Run(run func(sleepNWake bool)) *MockNetworkManager_Sleep_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(bool))
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_Sleep_Call) Return(_a0 error) *MockNetworkManager_Sleep_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockNetworkManager_Sleep_Call) RunAndReturn(run func(bool) error) *MockNetworkManager_Sleep_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// State provides a mock function with no fields
+func (_m *MockNetworkManager) State() (gonetworkmanager.NmState, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for State")
+	}
+
+	var r0 gonetworkmanager.NmState
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmState, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() gonetworkmanager.NmState); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(gonetworkmanager.NmState)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockNetworkManager_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State'
+type MockNetworkManager_State_Call struct {
+	*mock.Call
+}
+
+// State is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) State() *MockNetworkManager_State_Call {
+	return &MockNetworkManager_State_Call{Call: _e.mock.On("State")}
+}
+
+func (_c *MockNetworkManager_State_Call) Run(run func()) *MockNetworkManager_State_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_State_Call) Return(_a0 gonetworkmanager.NmState, _a1 error) *MockNetworkManager_State_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockNetworkManager_State_Call) RunAndReturn(run func() (gonetworkmanager.NmState, error)) *MockNetworkManager_State_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Subscribe provides a mock function with no fields
+func (_m *MockNetworkManager) Subscribe() <-chan *dbus.Signal {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Subscribe")
+	}
+
+	var r0 <-chan *dbus.Signal
+	if rf, ok := ret.Get(0).(func() <-chan *dbus.Signal); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(<-chan *dbus.Signal)
+		}
+	}
+
+	return r0
+}
+
+// MockNetworkManager_Subscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Subscribe'
+type MockNetworkManager_Subscribe_Call struct {
+	*mock.Call
+}
+
+// Subscribe is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) Subscribe() *MockNetworkManager_Subscribe_Call {
+	return &MockNetworkManager_Subscribe_Call{Call: _e.mock.On("Subscribe")}
+}
+
+func (_c *MockNetworkManager_Subscribe_Call) Run(run func()) *MockNetworkManager_Subscribe_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_Subscribe_Call) Return(_a0 <-chan *dbus.Signal) *MockNetworkManager_Subscribe_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockNetworkManager_Subscribe_Call) RunAndReturn(run func() <-chan *dbus.Signal) *MockNetworkManager_Subscribe_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Unsubscribe provides a mock function with no fields
+func (_m *MockNetworkManager) Unsubscribe() {
+	_m.Called()
+}
+
+// MockNetworkManager_Unsubscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unsubscribe'
+type MockNetworkManager_Unsubscribe_Call struct {
+	*mock.Call
+}
+
+// Unsubscribe is a helper method to define mock.On call
+func (_e *MockNetworkManager_Expecter) Unsubscribe() *MockNetworkManager_Unsubscribe_Call {
+	return &MockNetworkManager_Unsubscribe_Call{Call: _e.mock.On("Unsubscribe")}
+}
+
+func (_c *MockNetworkManager_Unsubscribe_Call) Run(run func()) *MockNetworkManager_Unsubscribe_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockNetworkManager_Unsubscribe_Call) Return() *MockNetworkManager_Unsubscribe_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockNetworkManager_Unsubscribe_Call) RunAndReturn(run func()) *MockNetworkManager_Unsubscribe_Call {
+	_c.Run(run)
+	return _c
+}
+
+// NewMockNetworkManager creates a new instance of MockNetworkManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockNetworkManager(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockNetworkManager {
+	mock := &MockNetworkManager{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Settings.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Settings.go
new file mode 100644
index 0000000..20f488e
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Settings.go
@@ -0,0 +1,467 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package gonetworkmanager
+
+import (
+	gonetworkmanager "github.com/Wifx/gonetworkmanager/v2"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockSettings is an autogenerated mock type for the Settings type
+type MockSettings struct {
+	mock.Mock
+}
+
+type MockSettings_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockSettings) EXPECT() *MockSettings_Expecter {
+	return &MockSettings_Expecter{mock: &_m.Mock}
+}
+
+// AddConnection provides a mock function with given fields: settings
+func (_m *MockSettings) AddConnection(settings gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error) {
+	ret := _m.Called(settings)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AddConnection")
+	}
+
+	var r0 gonetworkmanager.Connection
+	var r1 error
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)); ok {
+		return rf(settings)
+	}
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) gonetworkmanager.Connection); ok {
+		r0 = rf(settings)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.Connection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(gonetworkmanager.ConnectionSettings) error); ok {
+		r1 = rf(settings)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSettings_AddConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddConnection'
+type MockSettings_AddConnection_Call struct {
+	*mock.Call
+}
+
+// AddConnection is a helper method to define mock.On call
+//   - settings gonetworkmanager.ConnectionSettings
+func (_e *MockSettings_Expecter) AddConnection(settings interface{}) *MockSettings_AddConnection_Call {
+	return &MockSettings_AddConnection_Call{Call: _e.mock.On("AddConnection", settings)}
+}
+
+func (_c *MockSettings_AddConnection_Call) Run(run func(settings gonetworkmanager.ConnectionSettings)) *MockSettings_AddConnection_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(gonetworkmanager.ConnectionSettings))
+	})
+	return _c
+}
+
+func (_c *MockSettings_AddConnection_Call) Return(_a0 gonetworkmanager.Connection, _a1 error) *MockSettings_AddConnection_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSettings_AddConnection_Call) RunAndReturn(run func(gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)) *MockSettings_AddConnection_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// AddConnectionUnsaved provides a mock function with given fields: settings
+func (_m *MockSettings) AddConnectionUnsaved(settings gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error) {
+	ret := _m.Called(settings)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AddConnectionUnsaved")
+	}
+
+	var r0 gonetworkmanager.Connection
+	var r1 error
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)); ok {
+		return rf(settings)
+	}
+	if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) gonetworkmanager.Connection); ok {
+		r0 = rf(settings)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.Connection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(gonetworkmanager.ConnectionSettings) error); ok {
+		r1 = rf(settings)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSettings_AddConnectionUnsaved_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddConnectionUnsaved'
+type MockSettings_AddConnectionUnsaved_Call struct {
+	*mock.Call
+}
+
+// AddConnectionUnsaved is a helper method to define mock.On call
+//   - settings gonetworkmanager.ConnectionSettings
+func (_e *MockSettings_Expecter) AddConnectionUnsaved(settings interface{}) *MockSettings_AddConnectionUnsaved_Call {
+	return &MockSettings_AddConnectionUnsaved_Call{Call: _e.mock.On("AddConnectionUnsaved", settings)}
+}
+
+func (_c *MockSettings_AddConnectionUnsaved_Call) Run(run func(settings gonetworkmanager.ConnectionSettings)) *MockSettings_AddConnectionUnsaved_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(gonetworkmanager.ConnectionSettings))
+	})
+	return _c
+}
+
+func (_c *MockSettings_AddConnectionUnsaved_Call) Return(_a0 gonetworkmanager.Connection, _a1 error) *MockSettings_AddConnectionUnsaved_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSettings_AddConnectionUnsaved_Call) RunAndReturn(run func(gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)) *MockSettings_AddConnectionUnsaved_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetConnectionByUUID provides a mock function with given fields: uuid
+func (_m *MockSettings) GetConnectionByUUID(uuid string) (gonetworkmanager.Connection, error) {
+	ret := _m.Called(uuid)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetConnectionByUUID")
+	}
+
+	var r0 gonetworkmanager.Connection
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (gonetworkmanager.Connection, error)); ok {
+		return rf(uuid)
+	}
+	if rf, ok := ret.Get(0).(func(string) gonetworkmanager.Connection); ok {
+		r0 = rf(uuid)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(gonetworkmanager.Connection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(uuid)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSettings_GetConnectionByUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConnectionByUUID'
+type MockSettings_GetConnectionByUUID_Call struct {
+	*mock.Call
+}
+
+// GetConnectionByUUID is a helper method to define mock.On call
+//   - uuid string
+func (_e *MockSettings_Expecter) GetConnectionByUUID(uuid interface{}) *MockSettings_GetConnectionByUUID_Call {
+	return &MockSettings_GetConnectionByUUID_Call{Call: _e.mock.On("GetConnectionByUUID", uuid)}
+}
+
+func (_c *MockSettings_GetConnectionByUUID_Call) Run(run func(uuid string)) *MockSettings_GetConnectionByUUID_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockSettings_GetConnectionByUUID_Call) Return(_a0 gonetworkmanager.Connection, _a1 error) *MockSettings_GetConnectionByUUID_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSettings_GetConnectionByUUID_Call) RunAndReturn(run func(string) (gonetworkmanager.Connection, error)) *MockSettings_GetConnectionByUUID_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyCanModify provides a mock function with no fields
+func (_m *MockSettings) GetPropertyCanModify() (bool, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyCanModify")
+	}
+
+	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
+}
+
+// MockSettings_GetPropertyCanModify_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyCanModify'
+type MockSettings_GetPropertyCanModify_Call struct {
+	*mock.Call
+}
+
+// GetPropertyCanModify is a helper method to define mock.On call
+func (_e *MockSettings_Expecter) GetPropertyCanModify() *MockSettings_GetPropertyCanModify_Call {
+	return &MockSettings_GetPropertyCanModify_Call{Call: _e.mock.On("GetPropertyCanModify")}
+}
+
+func (_c *MockSettings_GetPropertyCanModify_Call) Run(run func()) *MockSettings_GetPropertyCanModify_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSettings_GetPropertyCanModify_Call) Return(_a0 bool, _a1 error) *MockSettings_GetPropertyCanModify_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSettings_GetPropertyCanModify_Call) RunAndReturn(run func() (bool, error)) *MockSettings_GetPropertyCanModify_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetPropertyHostname provides a mock function with no fields
+func (_m *MockSettings) GetPropertyHostname() (string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetPropertyHostname")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSettings_GetPropertyHostname_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPropertyHostname'
+type MockSettings_GetPropertyHostname_Call struct {
+	*mock.Call
+}
+
+// GetPropertyHostname is a helper method to define mock.On call
+func (_e *MockSettings_Expecter) GetPropertyHostname() *MockSettings_GetPropertyHostname_Call {
+	return &MockSettings_GetPropertyHostname_Call{Call: _e.mock.On("GetPropertyHostname")}
+}
+
+func (_c *MockSettings_GetPropertyHostname_Call) Run(run func()) *MockSettings_GetPropertyHostname_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSettings_GetPropertyHostname_Call) Return(_a0 string, _a1 error) *MockSettings_GetPropertyHostname_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSettings_GetPropertyHostname_Call) RunAndReturn(run func() (string, error)) *MockSettings_GetPropertyHostname_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ListConnections provides a mock function with no fields
+func (_m *MockSettings) ListConnections() ([]gonetworkmanager.Connection, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for ListConnections")
+	}
+
+	var r0 []gonetworkmanager.Connection
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Connection, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []gonetworkmanager.Connection); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]gonetworkmanager.Connection)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockSettings_ListConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConnections'
+type MockSettings_ListConnections_Call struct {
+	*mock.Call
+}
+
+// ListConnections is a helper method to define mock.On call
+func (_e *MockSettings_Expecter) ListConnections() *MockSettings_ListConnections_Call {
+	return &MockSettings_ListConnections_Call{Call: _e.mock.On("ListConnections")}
+}
+
+func (_c *MockSettings_ListConnections_Call) Run(run func()) *MockSettings_ListConnections_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSettings_ListConnections_Call) Return(_a0 []gonetworkmanager.Connection, _a1 error) *MockSettings_ListConnections_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockSettings_ListConnections_Call) RunAndReturn(run func() ([]gonetworkmanager.Connection, error)) *MockSettings_ListConnections_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// ReloadConnections provides a mock function with no fields
+func (_m *MockSettings) ReloadConnections() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for ReloadConnections")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockSettings_ReloadConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReloadConnections'
+type MockSettings_ReloadConnections_Call struct {
+	*mock.Call
+}
+
+// ReloadConnections is a helper method to define mock.On call
+func (_e *MockSettings_Expecter) ReloadConnections() *MockSettings_ReloadConnections_Call {
+	return &MockSettings_ReloadConnections_Call{Call: _e.mock.On("ReloadConnections")}
+}
+
+func (_c *MockSettings_ReloadConnections_Call) Run(run func()) *MockSettings_ReloadConnections_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSettings_ReloadConnections_Call) Return(_a0 error) *MockSettings_ReloadConnections_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSettings_ReloadConnections_Call) RunAndReturn(run func() error) *MockSettings_ReloadConnections_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SaveHostname provides a mock function with given fields: hostname
+func (_m *MockSettings) SaveHostname(hostname string) error {
+	ret := _m.Called(hostname)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SaveHostname")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(hostname)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockSettings_SaveHostname_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveHostname'
+type MockSettings_SaveHostname_Call struct {
+	*mock.Call
+}
+
+// SaveHostname is a helper method to define mock.On call
+//   - hostname string
+func (_e *MockSettings_Expecter) SaveHostname(hostname interface{}) *MockSettings_SaveHostname_Call {
+	return &MockSettings_SaveHostname_Call{Call: _e.mock.On("SaveHostname", hostname)}
+}
+
+func (_c *MockSettings_SaveHostname_Call) Run(run func(hostname string)) *MockSettings_SaveHostname_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockSettings_SaveHostname_Call) Return(_a0 error) *MockSettings_SaveHostname_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSettings_SaveHostname_Call) RunAndReturn(run func(string) error) *MockSettings_SaveHostname_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockSettings creates a new instance of MockSettings. 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 NewMockSettings(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockSettings {
+	mock := &MockSettings{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/godbus/dbus/v5/mock_BusObject.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/godbus/dbus/v5/mock_BusObject.go
new file mode 100644
index 0000000..c0d1a3f
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/github.com/godbus/dbus/v5/mock_BusObject.go
@@ -0,0 +1,649 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package dbus
+
+import (
+	context "context"
+
+	dbus "github.com/godbus/dbus/v5"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockBusObject is an autogenerated mock type for the BusObject type
+type MockBusObject struct {
+	mock.Mock
+}
+
+type MockBusObject_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockBusObject) EXPECT() *MockBusObject_Expecter {
+	return &MockBusObject_Expecter{mock: &_m.Mock}
+}
+
+// AddMatchSignal provides a mock function with given fields: iface, member, options
+func (_m *MockBusObject) AddMatchSignal(iface string, member string, options ...dbus.MatchOption) *dbus.Call {
+	_va := make([]interface{}, len(options))
+	for _i := range options {
+		_va[_i] = options[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, iface, member)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AddMatchSignal")
+	}
+
+	var r0 *dbus.Call
+	if rf, ok := ret.Get(0).(func(string, string, ...dbus.MatchOption) *dbus.Call); ok {
+		r0 = rf(iface, member, options...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*dbus.Call)
+		}
+	}
+
+	return r0
+}
+
+// MockBusObject_AddMatchSignal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddMatchSignal'
+type MockBusObject_AddMatchSignal_Call struct {
+	*mock.Call
+}
+
+// AddMatchSignal is a helper method to define mock.On call
+//   - iface string
+//   - member string
+//   - options ...dbus.MatchOption
+func (_e *MockBusObject_Expecter) AddMatchSignal(iface interface{}, member interface{}, options ...interface{}) *MockBusObject_AddMatchSignal_Call {
+	return &MockBusObject_AddMatchSignal_Call{Call: _e.mock.On("AddMatchSignal",
+		append([]interface{}{iface, member}, options...)...)}
+}
+
+func (_c *MockBusObject_AddMatchSignal_Call) Run(run func(iface string, member string, options ...dbus.MatchOption)) *MockBusObject_AddMatchSignal_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]dbus.MatchOption, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(dbus.MatchOption)
+			}
+		}
+		run(args[0].(string), args[1].(string), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockBusObject_AddMatchSignal_Call) Return(_a0 *dbus.Call) *MockBusObject_AddMatchSignal_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBusObject_AddMatchSignal_Call) RunAndReturn(run func(string, string, ...dbus.MatchOption) *dbus.Call) *MockBusObject_AddMatchSignal_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Call provides a mock function with given fields: method, flags, args
+func (_m *MockBusObject) Call(method string, flags dbus.Flags, args ...interface{}) *dbus.Call {
+	var _ca []interface{}
+	_ca = append(_ca, method, flags)
+	_ca = append(_ca, args...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Call")
+	}
+
+	var r0 *dbus.Call
+	if rf, ok := ret.Get(0).(func(string, dbus.Flags, ...interface{}) *dbus.Call); ok {
+		r0 = rf(method, flags, args...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*dbus.Call)
+		}
+	}
+
+	return r0
+}
+
+// MockBusObject_Call_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Call'
+type MockBusObject_Call_Call struct {
+	*mock.Call
+}
+
+// Call is a helper method to define mock.On call
+//   - method string
+//   - flags dbus.Flags
+//   - args ...interface{}
+func (_e *MockBusObject_Expecter) Call(method interface{}, flags interface{}, args ...interface{}) *MockBusObject_Call_Call {
+	return &MockBusObject_Call_Call{Call: _e.mock.On("Call",
+		append([]interface{}{method, flags}, args...)...)}
+}
+
+func (_c *MockBusObject_Call_Call) Run(run func(method string, flags dbus.Flags, args ...interface{})) *MockBusObject_Call_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]interface{}, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(interface{})
+			}
+		}
+		run(args[0].(string), args[1].(dbus.Flags), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockBusObject_Call_Call) Return(_a0 *dbus.Call) *MockBusObject_Call_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBusObject_Call_Call) RunAndReturn(run func(string, dbus.Flags, ...interface{}) *dbus.Call) *MockBusObject_Call_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CallWithContext provides a mock function with given fields: ctx, method, flags, args
+func (_m *MockBusObject) CallWithContext(ctx context.Context, method string, flags dbus.Flags, args ...interface{}) *dbus.Call {
+	var _ca []interface{}
+	_ca = append(_ca, ctx, method, flags)
+	_ca = append(_ca, args...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CallWithContext")
+	}
+
+	var r0 *dbus.Call
+	if rf, ok := ret.Get(0).(func(context.Context, string, dbus.Flags, ...interface{}) *dbus.Call); ok {
+		r0 = rf(ctx, method, flags, args...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*dbus.Call)
+		}
+	}
+
+	return r0
+}
+
+// MockBusObject_CallWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CallWithContext'
+type MockBusObject_CallWithContext_Call struct {
+	*mock.Call
+}
+
+// CallWithContext is a helper method to define mock.On call
+//   - ctx context.Context
+//   - method string
+//   - flags dbus.Flags
+//   - args ...interface{}
+func (_e *MockBusObject_Expecter) CallWithContext(ctx interface{}, method interface{}, flags interface{}, args ...interface{}) *MockBusObject_CallWithContext_Call {
+	return &MockBusObject_CallWithContext_Call{Call: _e.mock.On("CallWithContext",
+		append([]interface{}{ctx, method, flags}, args...)...)}
+}
+
+func (_c *MockBusObject_CallWithContext_Call) Run(run func(ctx context.Context, method string, flags dbus.Flags, args ...interface{})) *MockBusObject_CallWithContext_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]interface{}, len(args)-3)
+		for i, a := range args[3:] {
+			if a != nil {
+				variadicArgs[i] = a.(interface{})
+			}
+		}
+		run(args[0].(context.Context), args[1].(string), args[2].(dbus.Flags), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockBusObject_CallWithContext_Call) Return(_a0 *dbus.Call) *MockBusObject_CallWithContext_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBusObject_CallWithContext_Call) RunAndReturn(run func(context.Context, string, dbus.Flags, ...interface{}) *dbus.Call) *MockBusObject_CallWithContext_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Destination provides a mock function with no fields
+func (_m *MockBusObject) Destination() string {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Destination")
+	}
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// MockBusObject_Destination_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Destination'
+type MockBusObject_Destination_Call struct {
+	*mock.Call
+}
+
+// Destination is a helper method to define mock.On call
+func (_e *MockBusObject_Expecter) Destination() *MockBusObject_Destination_Call {
+	return &MockBusObject_Destination_Call{Call: _e.mock.On("Destination")}
+}
+
+func (_c *MockBusObject_Destination_Call) Run(run func()) *MockBusObject_Destination_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockBusObject_Destination_Call) Return(_a0 string) *MockBusObject_Destination_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBusObject_Destination_Call) RunAndReturn(run func() string) *MockBusObject_Destination_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetProperty provides a mock function with given fields: p
+func (_m *MockBusObject) GetProperty(p string) (dbus.Variant, error) {
+	ret := _m.Called(p)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetProperty")
+	}
+
+	var r0 dbus.Variant
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (dbus.Variant, error)); ok {
+		return rf(p)
+	}
+	if rf, ok := ret.Get(0).(func(string) dbus.Variant); ok {
+		r0 = rf(p)
+	} else {
+		r0 = ret.Get(0).(dbus.Variant)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(p)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockBusObject_GetProperty_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProperty'
+type MockBusObject_GetProperty_Call struct {
+	*mock.Call
+}
+
+// GetProperty is a helper method to define mock.On call
+//   - p string
+func (_e *MockBusObject_Expecter) GetProperty(p interface{}) *MockBusObject_GetProperty_Call {
+	return &MockBusObject_GetProperty_Call{Call: _e.mock.On("GetProperty", p)}
+}
+
+func (_c *MockBusObject_GetProperty_Call) Run(run func(p string)) *MockBusObject_GetProperty_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockBusObject_GetProperty_Call) Return(_a0 dbus.Variant, _a1 error) *MockBusObject_GetProperty_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockBusObject_GetProperty_Call) RunAndReturn(run func(string) (dbus.Variant, error)) *MockBusObject_GetProperty_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Go provides a mock function with given fields: method, flags, ch, args
+func (_m *MockBusObject) Go(method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{}) *dbus.Call {
+	var _ca []interface{}
+	_ca = append(_ca, method, flags, ch)
+	_ca = append(_ca, args...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Go")
+	}
+
+	var r0 *dbus.Call
+	if rf, ok := ret.Get(0).(func(string, dbus.Flags, chan *dbus.Call, ...interface{}) *dbus.Call); ok {
+		r0 = rf(method, flags, ch, args...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*dbus.Call)
+		}
+	}
+
+	return r0
+}
+
+// MockBusObject_Go_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Go'
+type MockBusObject_Go_Call struct {
+	*mock.Call
+}
+
+// Go is a helper method to define mock.On call
+//   - method string
+//   - flags dbus.Flags
+//   - ch chan *dbus.Call
+//   - args ...interface{}
+func (_e *MockBusObject_Expecter) Go(method interface{}, flags interface{}, ch interface{}, args ...interface{}) *MockBusObject_Go_Call {
+	return &MockBusObject_Go_Call{Call: _e.mock.On("Go",
+		append([]interface{}{method, flags, ch}, args...)...)}
+}
+
+func (_c *MockBusObject_Go_Call) Run(run func(method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{})) *MockBusObject_Go_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]interface{}, len(args)-3)
+		for i, a := range args[3:] {
+			if a != nil {
+				variadicArgs[i] = a.(interface{})
+			}
+		}
+		run(args[0].(string), args[1].(dbus.Flags), args[2].(chan *dbus.Call), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockBusObject_Go_Call) Return(_a0 *dbus.Call) *MockBusObject_Go_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBusObject_Go_Call) RunAndReturn(run func(string, dbus.Flags, chan *dbus.Call, ...interface{}) *dbus.Call) *MockBusObject_Go_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GoWithContext provides a mock function with given fields: ctx, method, flags, ch, args
+func (_m *MockBusObject) GoWithContext(ctx context.Context, method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{}) *dbus.Call {
+	var _ca []interface{}
+	_ca = append(_ca, ctx, method, flags, ch)
+	_ca = append(_ca, args...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GoWithContext")
+	}
+
+	var r0 *dbus.Call
+	if rf, ok := ret.Get(0).(func(context.Context, string, dbus.Flags, chan *dbus.Call, ...interface{}) *dbus.Call); ok {
+		r0 = rf(ctx, method, flags, ch, args...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*dbus.Call)
+		}
+	}
+
+	return r0
+}
+
+// MockBusObject_GoWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoWithContext'
+type MockBusObject_GoWithContext_Call struct {
+	*mock.Call
+}
+
+// GoWithContext is a helper method to define mock.On call
+//   - ctx context.Context
+//   - method string
+//   - flags dbus.Flags
+//   - ch chan *dbus.Call
+//   - args ...interface{}
+func (_e *MockBusObject_Expecter) GoWithContext(ctx interface{}, method interface{}, flags interface{}, ch interface{}, args ...interface{}) *MockBusObject_GoWithContext_Call {
+	return &MockBusObject_GoWithContext_Call{Call: _e.mock.On("GoWithContext",
+		append([]interface{}{ctx, method, flags, ch}, args...)...)}
+}
+
+func (_c *MockBusObject_GoWithContext_Call) Run(run func(ctx context.Context, method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{})) *MockBusObject_GoWithContext_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]interface{}, len(args)-4)
+		for i, a := range args[4:] {
+			if a != nil {
+				variadicArgs[i] = a.(interface{})
+			}
+		}
+		run(args[0].(context.Context), args[1].(string), args[2].(dbus.Flags), args[3].(chan *dbus.Call), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockBusObject_GoWithContext_Call) Return(_a0 *dbus.Call) *MockBusObject_GoWithContext_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBusObject_GoWithContext_Call) RunAndReturn(run func(context.Context, string, dbus.Flags, chan *dbus.Call, ...interface{}) *dbus.Call) *MockBusObject_GoWithContext_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Path provides a mock function with no fields
+func (_m *MockBusObject) Path() dbus.ObjectPath {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Path")
+	}
+
+	var r0 dbus.ObjectPath
+	if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(dbus.ObjectPath)
+	}
+
+	return r0
+}
+
+// MockBusObject_Path_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Path'
+type MockBusObject_Path_Call struct {
+	*mock.Call
+}
+
+// Path is a helper method to define mock.On call
+func (_e *MockBusObject_Expecter) Path() *MockBusObject_Path_Call {
+	return &MockBusObject_Path_Call{Call: _e.mock.On("Path")}
+}
+
+func (_c *MockBusObject_Path_Call) Run(run func()) *MockBusObject_Path_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockBusObject_Path_Call) Return(_a0 dbus.ObjectPath) *MockBusObject_Path_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBusObject_Path_Call) RunAndReturn(run func() dbus.ObjectPath) *MockBusObject_Path_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RemoveMatchSignal provides a mock function with given fields: iface, member, options
+func (_m *MockBusObject) RemoveMatchSignal(iface string, member string, options ...dbus.MatchOption) *dbus.Call {
+	_va := make([]interface{}, len(options))
+	for _i := range options {
+		_va[_i] = options[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, iface, member)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoveMatchSignal")
+	}
+
+	var r0 *dbus.Call
+	if rf, ok := ret.Get(0).(func(string, string, ...dbus.MatchOption) *dbus.Call); ok {
+		r0 = rf(iface, member, options...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*dbus.Call)
+		}
+	}
+
+	return r0
+}
+
+// MockBusObject_RemoveMatchSignal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveMatchSignal'
+type MockBusObject_RemoveMatchSignal_Call struct {
+	*mock.Call
+}
+
+// RemoveMatchSignal is a helper method to define mock.On call
+//   - iface string
+//   - member string
+//   - options ...dbus.MatchOption
+func (_e *MockBusObject_Expecter) RemoveMatchSignal(iface interface{}, member interface{}, options ...interface{}) *MockBusObject_RemoveMatchSignal_Call {
+	return &MockBusObject_RemoveMatchSignal_Call{Call: _e.mock.On("RemoveMatchSignal",
+		append([]interface{}{iface, member}, options...)...)}
+}
+
+func (_c *MockBusObject_RemoveMatchSignal_Call) Run(run func(iface string, member string, options ...dbus.MatchOption)) *MockBusObject_RemoveMatchSignal_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]dbus.MatchOption, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(dbus.MatchOption)
+			}
+		}
+		run(args[0].(string), args[1].(string), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockBusObject_RemoveMatchSignal_Call) Return(_a0 *dbus.Call) *MockBusObject_RemoveMatchSignal_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBusObject_RemoveMatchSignal_Call) RunAndReturn(run func(string, string, ...dbus.MatchOption) *dbus.Call) *MockBusObject_RemoveMatchSignal_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetProperty provides a mock function with given fields: p, v
+func (_m *MockBusObject) SetProperty(p string, v interface{}) error {
+	ret := _m.Called(p, v)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetProperty")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, interface{}) error); ok {
+		r0 = rf(p, v)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockBusObject_SetProperty_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetProperty'
+type MockBusObject_SetProperty_Call struct {
+	*mock.Call
+}
+
+// SetProperty is a helper method to define mock.On call
+//   - p string
+//   - v interface{}
+func (_e *MockBusObject_Expecter) SetProperty(p interface{}, v interface{}) *MockBusObject_SetProperty_Call {
+	return &MockBusObject_SetProperty_Call{Call: _e.mock.On("SetProperty", p, v)}
+}
+
+func (_c *MockBusObject_SetProperty_Call) Run(run func(p string, v interface{})) *MockBusObject_SetProperty_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(interface{}))
+	})
+	return _c
+}
+
+func (_c *MockBusObject_SetProperty_Call) Return(_a0 error) *MockBusObject_SetProperty_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBusObject_SetProperty_Call) RunAndReturn(run func(string, interface{}) error) *MockBusObject_SetProperty_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// StoreProperty provides a mock function with given fields: p, value
+func (_m *MockBusObject) StoreProperty(p string, value interface{}) error {
+	ret := _m.Called(p, value)
+
+	if len(ret) == 0 {
+		panic("no return value specified for StoreProperty")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, interface{}) error); ok {
+		r0 = rf(p, value)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockBusObject_StoreProperty_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StoreProperty'
+type MockBusObject_StoreProperty_Call struct {
+	*mock.Call
+}
+
+// StoreProperty is a helper method to define mock.On call
+//   - p string
+//   - value interface{}
+func (_e *MockBusObject_Expecter) StoreProperty(p interface{}, value interface{}) *MockBusObject_StoreProperty_Call {
+	return &MockBusObject_StoreProperty_Call{Call: _e.mock.On("StoreProperty", p, value)}
+}
+
+func (_c *MockBusObject_StoreProperty_Call) Run(run func(p string, value interface{})) *MockBusObject_StoreProperty_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(interface{}))
+	})
+	return _c
+}
+
+func (_c *MockBusObject_StoreProperty_Call) Return(_a0 error) *MockBusObject_StoreProperty_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBusObject_StoreProperty_Call) RunAndReturn(run func(string, interface{}) error) *MockBusObject_StoreProperty_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockBusObject creates a new instance of MockBusObject. 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 NewMockBusObject(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockBusObject {
+	mock := &MockBusObject{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/internal/plugins/mock_GitClient.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/internal/plugins/mock_GitClient.go
new file mode 100644
index 0000000..23e34f3
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/internal/plugins/mock_GitClient.go
@@ -0,0 +1,181 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package plugins
+
+import mock "github.com/stretchr/testify/mock"
+
+// MockGitClient is an autogenerated mock type for the GitClient type
+type MockGitClient struct {
+	mock.Mock
+}
+
+type MockGitClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockGitClient) EXPECT() *MockGitClient_Expecter {
+	return &MockGitClient_Expecter{mock: &_m.Mock}
+}
+
+// HasUpdates provides a mock function with given fields: path
+func (_m *MockGitClient) HasUpdates(path string) (bool, error) {
+	ret := _m.Called(path)
+
+	if len(ret) == 0 {
+		panic("no return value specified for HasUpdates")
+	}
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (bool, error)); ok {
+		return rf(path)
+	}
+	if rf, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = rf(path)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(path)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockGitClient_HasUpdates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasUpdates'
+type MockGitClient_HasUpdates_Call struct {
+	*mock.Call
+}
+
+// HasUpdates is a helper method to define mock.On call
+//   - path string
+func (_e *MockGitClient_Expecter) HasUpdates(path any) *MockGitClient_HasUpdates_Call {
+	return &MockGitClient_HasUpdates_Call{Call: _e.mock.On("HasUpdates", path)}
+}
+
+func (_c *MockGitClient_HasUpdates_Call) Run(run func(path string)) *MockGitClient_HasUpdates_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockGitClient_HasUpdates_Call) Return(_a0 bool, _a1 error) *MockGitClient_HasUpdates_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockGitClient_HasUpdates_Call) RunAndReturn(run func(string) (bool, error)) *MockGitClient_HasUpdates_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// PlainClone provides a mock function with given fields: path, url
+func (_m *MockGitClient) PlainClone(path string, url string) error {
+	ret := _m.Called(path, url)
+
+	if len(ret) == 0 {
+		panic("no return value specified for PlainClone")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(path, url)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockGitClient_PlainClone_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PlainClone'
+type MockGitClient_PlainClone_Call struct {
+	*mock.Call
+}
+
+// PlainClone is a helper method to define mock.On call
+//   - path string
+//   - url string
+func (_e *MockGitClient_Expecter) PlainClone(path any, url any) *MockGitClient_PlainClone_Call {
+	return &MockGitClient_PlainClone_Call{Call: _e.mock.On("PlainClone", path, url)}
+}
+
+func (_c *MockGitClient_PlainClone_Call) Run(run func(path string, url string)) *MockGitClient_PlainClone_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockGitClient_PlainClone_Call) Return(_a0 error) *MockGitClient_PlainClone_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockGitClient_PlainClone_Call) RunAndReturn(run func(string, string) error) *MockGitClient_PlainClone_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Pull provides a mock function with given fields: path
+func (_m *MockGitClient) Pull(path string) error {
+	ret := _m.Called(path)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Pull")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(path)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockGitClient_Pull_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pull'
+type MockGitClient_Pull_Call struct {
+	*mock.Call
+}
+
+// Pull is a helper method to define mock.On call
+//   - path string
+func (_e *MockGitClient_Expecter) Pull(path any) *MockGitClient_Pull_Call {
+	return &MockGitClient_Pull_Call{Call: _e.mock.On("Pull", path)}
+}
+
+func (_c *MockGitClient_Pull_Call) Run(run func(path string)) *MockGitClient_Pull_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockGitClient_Pull_Call) Return(_a0 error) *MockGitClient_Pull_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockGitClient_Pull_Call) RunAndReturn(run func(string) error) *MockGitClient_Pull_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockGitClient creates a new instance of MockGitClient. 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 NewMockGitClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockGitClient {
+	mock := &MockGitClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/net/mock_Conn.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/net/mock_Conn.go
new file mode 100644
index 0000000..248a0d8
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/net/mock_Conn.go
@@ -0,0 +1,427 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package net
+
+import (
+	net "net"
+
+	mock "github.com/stretchr/testify/mock"
+
+	time "time"
+)
+
+// MockConn is an autogenerated mock type for the Conn type
+type MockConn struct {
+	mock.Mock
+}
+
+type MockConn_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockConn) EXPECT() *MockConn_Expecter {
+	return &MockConn_Expecter{mock: &_m.Mock}
+}
+
+// Close provides a mock function with no fields
+func (_m *MockConn) Close() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Close")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockConn_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type MockConn_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+func (_e *MockConn_Expecter) Close() *MockConn_Close_Call {
+	return &MockConn_Close_Call{Call: _e.mock.On("Close")}
+}
+
+func (_c *MockConn_Close_Call) Run(run func()) *MockConn_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockConn_Close_Call) Return(_a0 error) *MockConn_Close_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockConn_Close_Call) RunAndReturn(run func() error) *MockConn_Close_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// LocalAddr provides a mock function with no fields
+func (_m *MockConn) LocalAddr() net.Addr {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for LocalAddr")
+	}
+
+	var r0 net.Addr
+	if rf, ok := ret.Get(0).(func() net.Addr); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(net.Addr)
+		}
+	}
+
+	return r0
+}
+
+// MockConn_LocalAddr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LocalAddr'
+type MockConn_LocalAddr_Call struct {
+	*mock.Call
+}
+
+// LocalAddr is a helper method to define mock.On call
+func (_e *MockConn_Expecter) LocalAddr() *MockConn_LocalAddr_Call {
+	return &MockConn_LocalAddr_Call{Call: _e.mock.On("LocalAddr")}
+}
+
+func (_c *MockConn_LocalAddr_Call) Run(run func()) *MockConn_LocalAddr_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockConn_LocalAddr_Call) Return(_a0 net.Addr) *MockConn_LocalAddr_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockConn_LocalAddr_Call) RunAndReturn(run func() net.Addr) *MockConn_LocalAddr_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Read provides a mock function with given fields: b
+func (_m *MockConn) Read(b []byte) (int, error) {
+	ret := _m.Called(b)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Read")
+	}
+
+	var r0 int
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]byte) (int, error)); ok {
+		return rf(b)
+	}
+	if rf, ok := ret.Get(0).(func([]byte) int); ok {
+		r0 = rf(b)
+	} else {
+		r0 = ret.Get(0).(int)
+	}
+
+	if rf, ok := ret.Get(1).(func([]byte) error); ok {
+		r1 = rf(b)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockConn_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'
+type MockConn_Read_Call struct {
+	*mock.Call
+}
+
+// Read is a helper method to define mock.On call
+//   - b []byte
+func (_e *MockConn_Expecter) Read(b interface{}) *MockConn_Read_Call {
+	return &MockConn_Read_Call{Call: _e.mock.On("Read", b)}
+}
+
+func (_c *MockConn_Read_Call) Run(run func(b []byte)) *MockConn_Read_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].([]byte))
+	})
+	return _c
+}
+
+func (_c *MockConn_Read_Call) Return(n int, err error) *MockConn_Read_Call {
+	_c.Call.Return(n, err)
+	return _c
+}
+
+func (_c *MockConn_Read_Call) RunAndReturn(run func([]byte) (int, error)) *MockConn_Read_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// RemoteAddr provides a mock function with no fields
+func (_m *MockConn) RemoteAddr() net.Addr {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for RemoteAddr")
+	}
+
+	var r0 net.Addr
+	if rf, ok := ret.Get(0).(func() net.Addr); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(net.Addr)
+		}
+	}
+
+	return r0
+}
+
+// MockConn_RemoteAddr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoteAddr'
+type MockConn_RemoteAddr_Call struct {
+	*mock.Call
+}
+
+// RemoteAddr is a helper method to define mock.On call
+func (_e *MockConn_Expecter) RemoteAddr() *MockConn_RemoteAddr_Call {
+	return &MockConn_RemoteAddr_Call{Call: _e.mock.On("RemoteAddr")}
+}
+
+func (_c *MockConn_RemoteAddr_Call) Run(run func()) *MockConn_RemoteAddr_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockConn_RemoteAddr_Call) Return(_a0 net.Addr) *MockConn_RemoteAddr_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockConn_RemoteAddr_Call) RunAndReturn(run func() net.Addr) *MockConn_RemoteAddr_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetDeadline provides a mock function with given fields: t
+func (_m *MockConn) SetDeadline(t time.Time) error {
+	ret := _m.Called(t)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetDeadline")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(time.Time) error); ok {
+		r0 = rf(t)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockConn_SetDeadline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDeadline'
+type MockConn_SetDeadline_Call struct {
+	*mock.Call
+}
+
+// SetDeadline is a helper method to define mock.On call
+//   - t time.Time
+func (_e *MockConn_Expecter) SetDeadline(t interface{}) *MockConn_SetDeadline_Call {
+	return &MockConn_SetDeadline_Call{Call: _e.mock.On("SetDeadline", t)}
+}
+
+func (_c *MockConn_SetDeadline_Call) Run(run func(t time.Time)) *MockConn_SetDeadline_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(time.Time))
+	})
+	return _c
+}
+
+func (_c *MockConn_SetDeadline_Call) Return(_a0 error) *MockConn_SetDeadline_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockConn_SetDeadline_Call) RunAndReturn(run func(time.Time) error) *MockConn_SetDeadline_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetReadDeadline provides a mock function with given fields: t
+func (_m *MockConn) SetReadDeadline(t time.Time) error {
+	ret := _m.Called(t)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetReadDeadline")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(time.Time) error); ok {
+		r0 = rf(t)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockConn_SetReadDeadline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetReadDeadline'
+type MockConn_SetReadDeadline_Call struct {
+	*mock.Call
+}
+
+// SetReadDeadline is a helper method to define mock.On call
+//   - t time.Time
+func (_e *MockConn_Expecter) SetReadDeadline(t interface{}) *MockConn_SetReadDeadline_Call {
+	return &MockConn_SetReadDeadline_Call{Call: _e.mock.On("SetReadDeadline", t)}
+}
+
+func (_c *MockConn_SetReadDeadline_Call) Run(run func(t time.Time)) *MockConn_SetReadDeadline_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(time.Time))
+	})
+	return _c
+}
+
+func (_c *MockConn_SetReadDeadline_Call) Return(_a0 error) *MockConn_SetReadDeadline_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockConn_SetReadDeadline_Call) RunAndReturn(run func(time.Time) error) *MockConn_SetReadDeadline_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetWriteDeadline provides a mock function with given fields: t
+func (_m *MockConn) SetWriteDeadline(t time.Time) error {
+	ret := _m.Called(t)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetWriteDeadline")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(time.Time) error); ok {
+		r0 = rf(t)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockConn_SetWriteDeadline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetWriteDeadline'
+type MockConn_SetWriteDeadline_Call struct {
+	*mock.Call
+}
+
+// SetWriteDeadline is a helper method to define mock.On call
+//   - t time.Time
+func (_e *MockConn_Expecter) SetWriteDeadline(t interface{}) *MockConn_SetWriteDeadline_Call {
+	return &MockConn_SetWriteDeadline_Call{Call: _e.mock.On("SetWriteDeadline", t)}
+}
+
+func (_c *MockConn_SetWriteDeadline_Call) Run(run func(t time.Time)) *MockConn_SetWriteDeadline_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(time.Time))
+	})
+	return _c
+}
+
+func (_c *MockConn_SetWriteDeadline_Call) Return(_a0 error) *MockConn_SetWriteDeadline_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockConn_SetWriteDeadline_Call) RunAndReturn(run func(time.Time) error) *MockConn_SetWriteDeadline_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Write provides a mock function with given fields: b
+func (_m *MockConn) Write(b []byte) (int, error) {
+	ret := _m.Called(b)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Write")
+	}
+
+	var r0 int
+	var r1 error
+	if rf, ok := ret.Get(0).(func([]byte) (int, error)); ok {
+		return rf(b)
+	}
+	if rf, ok := ret.Get(0).(func([]byte) int); ok {
+		r0 = rf(b)
+	} else {
+		r0 = ret.Get(0).(int)
+	}
+
+	if rf, ok := ret.Get(1).(func([]byte) error); ok {
+		r1 = rf(b)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockConn_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'
+type MockConn_Write_Call struct {
+	*mock.Call
+}
+
+// Write is a helper method to define mock.On call
+//   - b []byte
+func (_e *MockConn_Expecter) Write(b interface{}) *MockConn_Write_Call {
+	return &MockConn_Write_Call{Call: _e.mock.On("Write", b)}
+}
+
+func (_c *MockConn_Write_Call) Run(run func(b []byte)) *MockConn_Write_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].([]byte))
+	})
+	return _c
+}
+
+func (_c *MockConn_Write_Call) Return(n int, err error) *MockConn_Write_Call {
+	_c.Call.Return(n, err)
+	return _c
+}
+
+func (_c *MockConn_Write_Call) RunAndReturn(run func([]byte) (int, error)) *MockConn_Write_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockConn creates a new instance of MockConn. 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 NewMockConn(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockConn {
+	mock := &MockConn{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/network/mock_Backend.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/network/mock_Backend.go
new file mode 100644
index 0000000..d7eb2df
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/network/mock_Backend.go
@@ -0,0 +1,1975 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package mocks_network
+
+import (
+	network "github.com/AvengeMedia/DankMaterialShell/core/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
+}
+
+// DeleteVPN provides a mock function with given fields: uuidOrName
+func (_m *MockBackend) DeleteVPN(uuidOrName string) error {
+	ret := _m.Called(uuidOrName)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteVPN")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(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 interface{}) *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) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockBackend_DeleteVPN_Call) Return(_a0 error) *MockBackend_DeleteVPN_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBackend_DeleteVPN_Call) RunAndReturn(run func(string) error) *MockBackend_DeleteVPN_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
+}
+
+// DisconnectEthernetDevice provides a mock function with given fields: device
+func (_m *MockBackend) DisconnectEthernetDevice(device string) error {
+	ret := _m.Called(device)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DisconnectEthernetDevice")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(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 interface{}) *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) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockBackend_DisconnectEthernetDevice_Call) Return(_a0 error) *MockBackend_DisconnectEthernetDevice_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBackend_DisconnectEthernetDevice_Call) RunAndReturn(run func(string) error) *MockBackend_DisconnectEthernetDevice_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
+}
+
+// DisconnectWiFiDevice provides a mock function with given fields: device
+func (_m *MockBackend) DisconnectWiFiDevice(device string) error {
+	ret := _m.Called(device)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DisconnectWiFiDevice")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(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 interface{}) *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) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockBackend_DisconnectWiFiDevice_Call) Return(_a0 error) *MockBackend_DisconnectWiFiDevice_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBackend_DisconnectWiFiDevice_Call) RunAndReturn(run func(string) error) *MockBackend_DisconnectWiFiDevice_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
+}
+
+// GetEthernetDevices provides a mock function with no fields
+func (_m *MockBackend) GetEthernetDevices() []network.EthernetDevice {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetEthernetDevices")
+	}
+
+	var r0 []network.EthernetDevice
+	if rf, ok := ret.Get(0).(func() []network.EthernetDevice); ok {
+		r0 = rf()
+	} 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(_a0 []network.EthernetDevice) *MockBackend_GetEthernetDevices_Call {
+	_c.Call.Return(_a0)
+	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 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
+}
+
+// GetVPNConfig provides a mock function with given fields: uuidOrName
+func (_m *MockBackend) GetVPNConfig(uuidOrName string) (*network.VPNConfig, error) {
+	ret := _m.Called(uuidOrName)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetVPNConfig")
+	}
+
+	var r0 *network.VPNConfig
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (*network.VPNConfig, error)); ok {
+		return rf(uuidOrName)
+	}
+	if rf, ok := ret.Get(0).(func(string) *network.VPNConfig); ok {
+		r0 = rf(uuidOrName)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*network.VPNConfig)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(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 interface{}) *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) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockBackend_GetVPNConfig_Call) Return(_a0 *network.VPNConfig, _a1 error) *MockBackend_GetVPNConfig_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockBackend_GetVPNConfig_Call) RunAndReturn(run func(string) (*network.VPNConfig, error)) *MockBackend_GetVPNConfig_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetWiFiDevices provides a mock function with no fields
+func (_m *MockBackend) GetWiFiDevices() []network.WiFiDevice {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetWiFiDevices")
+	}
+
+	var r0 []network.WiFiDevice
+	if rf, ok := ret.Get(0).(func() []network.WiFiDevice); ok {
+		r0 = rf()
+	} 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(_a0 []network.WiFiDevice) *MockBackend_GetWiFiDevices_Call {
+	_c.Call.Return(_a0)
+	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 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
+}
+
+// GetWiFiQRCodeContent provides a mock function with given fields: ssid
+func (_m *MockBackend) GetWiFiQRCodeContent(ssid string) (string, error) {
+	ret := _m.Called(ssid)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetWiFiQRCodeContent")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (string, error)); ok {
+		return rf(ssid)
+	}
+	if rf, ok := ret.Get(0).(func(string) string); ok {
+		r0 = rf(ssid)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(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 interface{}) *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) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockBackend_GetWiFiQRCodeContent_Call) Return(_a0 string, _a1 error) *MockBackend_GetWiFiQRCodeContent_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockBackend_GetWiFiQRCodeContent_Call) RunAndReturn(run func(string) (string, error)) *MockBackend_GetWiFiQRCodeContent_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
+}
+
+// ImportVPN provides a mock function with given fields: filePath, name
+func (_m *MockBackend) ImportVPN(filePath string, name string) (*network.VPNImportResult, error) {
+	ret := _m.Called(filePath, name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ImportVPN")
+	}
+
+	var r0 *network.VPNImportResult
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (*network.VPNImportResult, error)); ok {
+		return rf(filePath, name)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) *network.VPNImportResult); ok {
+		r0 = rf(filePath, name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*network.VPNImportResult)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(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 interface{}, name interface{}) *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) {
+		run(args[0].(string), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockBackend_ImportVPN_Call) Return(_a0 *network.VPNImportResult, _a1 error) *MockBackend_ImportVPN_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockBackend_ImportVPN_Call) RunAndReturn(run func(string, string) (*network.VPNImportResult, error)) *MockBackend_ImportVPN_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
+}
+
+// ListVPNPlugins provides a mock function with no fields
+func (_m *MockBackend) ListVPNPlugins() ([]network.VPNPlugin, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for ListVPNPlugins")
+	}
+
+	var r0 []network.VPNPlugin
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]network.VPNPlugin, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []network.VPNPlugin); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]network.VPNPlugin)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} 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(_a0 []network.VPNPlugin, _a1 error) *MockBackend_ListVPNPlugins_Call {
+	_c.Call.Return(_a0, _a1)
+	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 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
+}
+
+// ScanWiFiDevice provides a mock function with given fields: device
+func (_m *MockBackend) ScanWiFiDevice(device string) error {
+	ret := _m.Called(device)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ScanWiFiDevice")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(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 interface{}) *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) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockBackend_ScanWiFiDevice_Call) Return(_a0 error) *MockBackend_ScanWiFiDevice_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBackend_ScanWiFiDevice_Call) RunAndReturn(run func(string) error) *MockBackend_ScanWiFiDevice_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
+}
+
+// SetVPNCredentials provides a mock function with given fields: uuid, username, password, save
+func (_m *MockBackend) SetVPNCredentials(uuid string, username string, password string, save bool) error {
+	ret := _m.Called(uuid, username, password, save)
+
+	if len(ret) == 0 {
+		panic("no return value specified for SetVPNCredentials")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string, string, bool) error); ok {
+		r0 = rf(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 interface{}, username interface{}, password interface{}, save interface{}) *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) {
+		run(args[0].(string), args[1].(string), args[2].(string), args[3].(bool))
+	})
+	return _c
+}
+
+func (_c *MockBackend_SetVPNCredentials_Call) Return(_a0 error) *MockBackend_SetVPNCredentials_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBackend_SetVPNCredentials_Call) RunAndReturn(run func(string, string, string, bool) error) *MockBackend_SetVPNCredentials_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
+}
+
+// UpdateVPNConfig provides a mock function with given fields: uuid, updates
+func (_m *MockBackend) UpdateVPNConfig(uuid string, updates map[string]interface{}) error {
+	ret := _m.Called(uuid, updates)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateVPNConfig")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, map[string]interface{}) error); ok {
+		r0 = rf(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]interface{}
+func (_e *MockBackend_Expecter) UpdateVPNConfig(uuid interface{}, updates interface{}) *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]interface{})) *MockBackend_UpdateVPNConfig_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(map[string]interface{}))
+	})
+	return _c
+}
+
+func (_c *MockBackend_UpdateVPNConfig_Call) Return(_a0 error) *MockBackend_UpdateVPNConfig_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockBackend_UpdateVPNConfig_Call) RunAndReturn(run func(string, map[string]interface{}) error) *MockBackend_UpdateVPNConfig_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
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/utils/mock_AppChecker.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/utils/mock_AppChecker.go
new file mode 100644
index 0000000..be220c4
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/utils/mock_AppChecker.go
@@ -0,0 +1,242 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package mocks_utils
+
+import mock "github.com/stretchr/testify/mock"
+
+// MockAppChecker is an autogenerated mock type for the AppChecker type
+type MockAppChecker struct {
+	mock.Mock
+}
+
+type MockAppChecker_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockAppChecker) EXPECT() *MockAppChecker_Expecter {
+	return &MockAppChecker_Expecter{mock: &_m.Mock}
+}
+
+// AnyCommandExists provides a mock function with given fields: cmds
+func (_m *MockAppChecker) AnyCommandExists(cmds ...string) bool {
+	_va := make([]interface{}, len(cmds))
+	for _i := range cmds {
+		_va[_i] = cmds[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AnyCommandExists")
+	}
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(...string) bool); ok {
+		r0 = rf(cmds...)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
+// MockAppChecker_AnyCommandExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnyCommandExists'
+type MockAppChecker_AnyCommandExists_Call struct {
+	*mock.Call
+}
+
+// AnyCommandExists is a helper method to define mock.On call
+//   - cmds ...string
+func (_e *MockAppChecker_Expecter) AnyCommandExists(cmds ...interface{}) *MockAppChecker_AnyCommandExists_Call {
+	return &MockAppChecker_AnyCommandExists_Call{Call: _e.mock.On("AnyCommandExists",
+		append([]interface{}{}, cmds...)...)}
+}
+
+func (_c *MockAppChecker_AnyCommandExists_Call) Run(run func(cmds ...string)) *MockAppChecker_AnyCommandExists_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]string, len(args)-0)
+		for i, a := range args[0:] {
+			if a != nil {
+				variadicArgs[i] = a.(string)
+			}
+		}
+		run(variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockAppChecker_AnyCommandExists_Call) Return(_a0 bool) *MockAppChecker_AnyCommandExists_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockAppChecker_AnyCommandExists_Call) RunAndReturn(run func(...string) bool) *MockAppChecker_AnyCommandExists_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// AnyFlatpakExists provides a mock function with given fields: flatpaks
+func (_m *MockAppChecker) AnyFlatpakExists(flatpaks ...string) bool {
+	_va := make([]interface{}, len(flatpaks))
+	for _i := range flatpaks {
+		_va[_i] = flatpaks[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AnyFlatpakExists")
+	}
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(...string) bool); ok {
+		r0 = rf(flatpaks...)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
+// MockAppChecker_AnyFlatpakExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnyFlatpakExists'
+type MockAppChecker_AnyFlatpakExists_Call struct {
+	*mock.Call
+}
+
+// AnyFlatpakExists is a helper method to define mock.On call
+//   - flatpaks ...string
+func (_e *MockAppChecker_Expecter) AnyFlatpakExists(flatpaks ...interface{}) *MockAppChecker_AnyFlatpakExists_Call {
+	return &MockAppChecker_AnyFlatpakExists_Call{Call: _e.mock.On("AnyFlatpakExists",
+		append([]interface{}{}, flatpaks...)...)}
+}
+
+func (_c *MockAppChecker_AnyFlatpakExists_Call) Run(run func(flatpaks ...string)) *MockAppChecker_AnyFlatpakExists_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]string, len(args)-0)
+		for i, a := range args[0:] {
+			if a != nil {
+				variadicArgs[i] = a.(string)
+			}
+		}
+		run(variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockAppChecker_AnyFlatpakExists_Call) Return(_a0 bool) *MockAppChecker_AnyFlatpakExists_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockAppChecker_AnyFlatpakExists_Call) RunAndReturn(run func(...string) bool) *MockAppChecker_AnyFlatpakExists_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CommandExists provides a mock function with given fields: cmd
+func (_m *MockAppChecker) CommandExists(cmd string) bool {
+	ret := _m.Called(cmd)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CommandExists")
+	}
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = rf(cmd)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
+// MockAppChecker_CommandExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CommandExists'
+type MockAppChecker_CommandExists_Call struct {
+	*mock.Call
+}
+
+// CommandExists is a helper method to define mock.On call
+//   - cmd string
+func (_e *MockAppChecker_Expecter) CommandExists(cmd interface{}) *MockAppChecker_CommandExists_Call {
+	return &MockAppChecker_CommandExists_Call{Call: _e.mock.On("CommandExists", cmd)}
+}
+
+func (_c *MockAppChecker_CommandExists_Call) Run(run func(cmd string)) *MockAppChecker_CommandExists_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockAppChecker_CommandExists_Call) Return(_a0 bool) *MockAppChecker_CommandExists_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockAppChecker_CommandExists_Call) RunAndReturn(run func(string) bool) *MockAppChecker_CommandExists_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FlatpakExists provides a mock function with given fields: name
+func (_m *MockAppChecker) FlatpakExists(name string) bool {
+	ret := _m.Called(name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FlatpakExists")
+	}
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = rf(name)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
+// MockAppChecker_FlatpakExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlatpakExists'
+type MockAppChecker_FlatpakExists_Call struct {
+	*mock.Call
+}
+
+// FlatpakExists is a helper method to define mock.On call
+//   - name string
+func (_e *MockAppChecker_Expecter) FlatpakExists(name interface{}) *MockAppChecker_FlatpakExists_Call {
+	return &MockAppChecker_FlatpakExists_Call{Call: _e.mock.On("FlatpakExists", name)}
+}
+
+func (_c *MockAppChecker_FlatpakExists_Call) Run(run func(name string)) *MockAppChecker_FlatpakExists_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockAppChecker_FlatpakExists_Call) Return(_a0 bool) *MockAppChecker_FlatpakExists_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockAppChecker_FlatpakExists_Call) RunAndReturn(run func(string) bool) *MockAppChecker_FlatpakExists_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockAppChecker creates a new instance of MockAppChecker. 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 NewMockAppChecker(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockAppChecker {
+	mock := &MockAppChecker{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/version/mock_VersionFetcher.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/version/mock_VersionFetcher.go
new file mode 100644
index 0000000..a6fa27c
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/version/mock_VersionFetcher.go
@@ -0,0 +1,144 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package mocks_version
+
+import mock "github.com/stretchr/testify/mock"
+
+// MockVersionFetcher is an autogenerated mock type for the VersionFetcher type
+type MockVersionFetcher struct {
+	mock.Mock
+}
+
+type MockVersionFetcher_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockVersionFetcher) EXPECT() *MockVersionFetcher_Expecter {
+	return &MockVersionFetcher_Expecter{mock: &_m.Mock}
+}
+
+// GetCurrentVersion provides a mock function with given fields: dmsPath
+func (_m *MockVersionFetcher) GetCurrentVersion(dmsPath string) (string, error) {
+	ret := _m.Called(dmsPath)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetCurrentVersion")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (string, error)); ok {
+		return rf(dmsPath)
+	}
+	if rf, ok := ret.Get(0).(func(string) string); ok {
+		r0 = rf(dmsPath)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(dmsPath)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockVersionFetcher_GetCurrentVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCurrentVersion'
+type MockVersionFetcher_GetCurrentVersion_Call struct {
+	*mock.Call
+}
+
+// GetCurrentVersion is a helper method to define mock.On call
+//   - dmsPath string
+func (_e *MockVersionFetcher_Expecter) GetCurrentVersion(dmsPath interface{}) *MockVersionFetcher_GetCurrentVersion_Call {
+	return &MockVersionFetcher_GetCurrentVersion_Call{Call: _e.mock.On("GetCurrentVersion", dmsPath)}
+}
+
+func (_c *MockVersionFetcher_GetCurrentVersion_Call) Run(run func(dmsPath string)) *MockVersionFetcher_GetCurrentVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockVersionFetcher_GetCurrentVersion_Call) Return(_a0 string, _a1 error) *MockVersionFetcher_GetCurrentVersion_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockVersionFetcher_GetCurrentVersion_Call) RunAndReturn(run func(string) (string, error)) *MockVersionFetcher_GetCurrentVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetLatestVersion provides a mock function with given fields: dmsPath
+func (_m *MockVersionFetcher) GetLatestVersion(dmsPath string) (string, error) {
+	ret := _m.Called(dmsPath)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetLatestVersion")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) (string, error)); ok {
+		return rf(dmsPath)
+	}
+	if rf, ok := ret.Get(0).(func(string) string); ok {
+		r0 = rf(dmsPath)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(dmsPath)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockVersionFetcher_GetLatestVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLatestVersion'
+type MockVersionFetcher_GetLatestVersion_Call struct {
+	*mock.Call
+}
+
+// GetLatestVersion is a helper method to define mock.On call
+//   - dmsPath string
+func (_e *MockVersionFetcher_Expecter) GetLatestVersion(dmsPath interface{}) *MockVersionFetcher_GetLatestVersion_Call {
+	return &MockVersionFetcher_GetLatestVersion_Call{Call: _e.mock.On("GetLatestVersion", dmsPath)}
+}
+
+func (_c *MockVersionFetcher_GetLatestVersion_Call) Run(run func(dmsPath string)) *MockVersionFetcher_GetLatestVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *MockVersionFetcher_GetLatestVersion_Call) Return(_a0 string, _a1 error) *MockVersionFetcher_GetLatestVersion_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockVersionFetcher_GetLatestVersion_Call) RunAndReturn(run func(string) (string, error)) *MockVersionFetcher_GetLatestVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockVersionFetcher creates a new instance of MockVersionFetcher. 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 NewMockVersionFetcher(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockVersionFetcher {
+	mock := &MockVersionFetcher{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/wlclient/mock_WaylandDisplay.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/wlclient/mock_WaylandDisplay.go
new file mode 100644
index 0000000..45d944b
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/wlclient/mock_WaylandDisplay.go
@@ -0,0 +1,229 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package mocks_wlclient
+
+import (
+	client "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockWaylandDisplay is an autogenerated mock type for the WaylandDisplay type
+type MockWaylandDisplay struct {
+	mock.Mock
+}
+
+type MockWaylandDisplay_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockWaylandDisplay) EXPECT() *MockWaylandDisplay_Expecter {
+	return &MockWaylandDisplay_Expecter{mock: &_m.Mock}
+}
+
+// Context provides a mock function with no fields
+func (_m *MockWaylandDisplay) Context() *client.Context {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Context")
+	}
+
+	var r0 *client.Context
+	if rf, ok := ret.Get(0).(func() *client.Context); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*client.Context)
+		}
+	}
+
+	return r0
+}
+
+// MockWaylandDisplay_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
+type MockWaylandDisplay_Context_Call struct {
+	*mock.Call
+}
+
+// Context is a helper method to define mock.On call
+func (_e *MockWaylandDisplay_Expecter) Context() *MockWaylandDisplay_Context_Call {
+	return &MockWaylandDisplay_Context_Call{Call: _e.mock.On("Context")}
+}
+
+func (_c *MockWaylandDisplay_Context_Call) Run(run func()) *MockWaylandDisplay_Context_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockWaylandDisplay_Context_Call) Return(_a0 *client.Context) *MockWaylandDisplay_Context_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockWaylandDisplay_Context_Call) RunAndReturn(run func() *client.Context) *MockWaylandDisplay_Context_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Destroy provides a mock function with no fields
+func (_m *MockWaylandDisplay) Destroy() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Destroy")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockWaylandDisplay_Destroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Destroy'
+type MockWaylandDisplay_Destroy_Call struct {
+	*mock.Call
+}
+
+// Destroy is a helper method to define mock.On call
+func (_e *MockWaylandDisplay_Expecter) Destroy() *MockWaylandDisplay_Destroy_Call {
+	return &MockWaylandDisplay_Destroy_Call{Call: _e.mock.On("Destroy")}
+}
+
+func (_c *MockWaylandDisplay_Destroy_Call) Run(run func()) *MockWaylandDisplay_Destroy_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockWaylandDisplay_Destroy_Call) Return(_a0 error) *MockWaylandDisplay_Destroy_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockWaylandDisplay_Destroy_Call) RunAndReturn(run func() error) *MockWaylandDisplay_Destroy_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetRegistry provides a mock function with no fields
+func (_m *MockWaylandDisplay) GetRegistry() (*client.Registry, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetRegistry")
+	}
+
+	var r0 *client.Registry
+	var r1 error
+	if rf, ok := ret.Get(0).(func() (*client.Registry, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() *client.Registry); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*client.Registry)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockWaylandDisplay_GetRegistry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegistry'
+type MockWaylandDisplay_GetRegistry_Call struct {
+	*mock.Call
+}
+
+// GetRegistry is a helper method to define mock.On call
+func (_e *MockWaylandDisplay_Expecter) GetRegistry() *MockWaylandDisplay_GetRegistry_Call {
+	return &MockWaylandDisplay_GetRegistry_Call{Call: _e.mock.On("GetRegistry")}
+}
+
+func (_c *MockWaylandDisplay_GetRegistry_Call) Run(run func()) *MockWaylandDisplay_GetRegistry_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockWaylandDisplay_GetRegistry_Call) Return(_a0 *client.Registry, _a1 error) *MockWaylandDisplay_GetRegistry_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockWaylandDisplay_GetRegistry_Call) RunAndReturn(run func() (*client.Registry, error)) *MockWaylandDisplay_GetRegistry_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Roundtrip provides a mock function with no fields
+func (_m *MockWaylandDisplay) Roundtrip() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Roundtrip")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockWaylandDisplay_Roundtrip_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Roundtrip'
+type MockWaylandDisplay_Roundtrip_Call struct {
+	*mock.Call
+}
+
+// Roundtrip is a helper method to define mock.On call
+func (_e *MockWaylandDisplay_Expecter) Roundtrip() *MockWaylandDisplay_Roundtrip_Call {
+	return &MockWaylandDisplay_Roundtrip_Call{Call: _e.mock.On("Roundtrip")}
+}
+
+func (_c *MockWaylandDisplay_Roundtrip_Call) Run(run func()) *MockWaylandDisplay_Roundtrip_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockWaylandDisplay_Roundtrip_Call) Return(_a0 error) *MockWaylandDisplay_Roundtrip_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockWaylandDisplay_Roundtrip_Call) RunAndReturn(run func() error) *MockWaylandDisplay_Roundtrip_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockWaylandDisplay creates a new instance of MockWaylandDisplay. 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 NewMockWaylandDisplay(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockWaylandDisplay {
+	mock := &MockWaylandDisplay{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/wlcontext/mock_WaylandContext.go b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/wlcontext/mock_WaylandContext.go
new file mode 100644
index 0000000..f5b0c35
--- /dev/null
+++ b/raveos-hyprland-theme/theme-data/DankMaterialShell/core/internal/mocks/wlcontext/mock_WaylandContext.go
@@ -0,0 +1,226 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package mocks_wlcontext
+
+import (
+	client "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockWaylandContext is an autogenerated mock type for the WaylandContext type
+type MockWaylandContext struct {
+	mock.Mock
+}
+
+type MockWaylandContext_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockWaylandContext) EXPECT() *MockWaylandContext_Expecter {
+	return &MockWaylandContext_Expecter{mock: &_m.Mock}
+}
+
+// Close provides a mock function with no fields
+func (_m *MockWaylandContext) Close() {
+	_m.Called()
+}
+
+// MockWaylandContext_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type MockWaylandContext_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+func (_e *MockWaylandContext_Expecter) Close() *MockWaylandContext_Close_Call {
+	return &MockWaylandContext_Close_Call{Call: _e.mock.On("Close")}
+}
+
+func (_c *MockWaylandContext_Close_Call) Run(run func()) *MockWaylandContext_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockWaylandContext_Close_Call) Return() *MockWaylandContext_Close_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockWaylandContext_Close_Call) RunAndReturn(run func()) *MockWaylandContext_Close_Call {
+	_c.Run(run)
+	return _c
+}
+
+// Display provides a mock function with no fields
+func (_m *MockWaylandContext) Display() *client.Display {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Display")
+	}
+
+	var r0 *client.Display
+	if rf, ok := ret.Get(0).(func() *client.Display); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*client.Display)
+		}
+	}
+
+	return r0
+}
+
+// MockWaylandContext_Display_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Display'
+type MockWaylandContext_Display_Call struct {
+	*mock.Call
+}
+
+// Display is a helper method to define mock.On call
+func (_e *MockWaylandContext_Expecter) Display() *MockWaylandContext_Display_Call {
+	return &MockWaylandContext_Display_Call{Call: _e.mock.On("Display")}
+}
+
+func (_c *MockWaylandContext_Display_Call) Run(run func()) *MockWaylandContext_Display_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockWaylandContext_Display_Call) Return(_a0 *client.Display) *MockWaylandContext_Display_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockWaylandContext_Display_Call) RunAndReturn(run func() *client.Display) *MockWaylandContext_Display_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FatalError provides a mock function with no fields
+func (_m *MockWaylandContext) FatalError() <-chan error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for FatalError")
+	}
+
+	var r0 <-chan error
+	if rf, ok := ret.Get(0).(func() <-chan error); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(<-chan error)
+		}
+	}
+
+	return r0
+}
+
+// MockWaylandContext_FatalError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FatalError'
+type MockWaylandContext_FatalError_Call struct {
+	*mock.Call
+}
+
+// FatalError is a helper method to define mock.On call
+func (_e *MockWaylandContext_Expecter) FatalError() *MockWaylandContext_FatalError_Call {
+	return &MockWaylandContext_FatalError_Call{Call: _e.mock.On("FatalError")}
+}
+
+func (_c *MockWaylandContext_FatalError_Call) Run(run func()) *MockWaylandContext_FatalError_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockWaylandContext_FatalError_Call) Return(_a0 <-chan error) *MockWaylandContext_FatalError_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockWaylandContext_FatalError_Call) RunAndReturn(run func() <-chan error) *MockWaylandContext_FatalError_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Post provides a mock function with given fields: fn
+func (_m *MockWaylandContext) Post(fn func()) {
+	_m.Called(fn)
+}
+
+// MockWaylandContext_Post_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Post'
+type MockWaylandContext_Post_Call struct {
+	*mock.Call
+}
+
+// Post is a helper method to define mock.On call
+//   - fn func()
+func (_e *MockWaylandContext_Expecter) Post(fn interface{}) *MockWaylandContext_Post_Call {
+	return &MockWaylandContext_Post_Call{Call: _e.mock.On("Post", fn)}
+}
+
+func (_c *MockWaylandContext_Post_Call) Run(run func(fn func())) *MockWaylandContext_Post_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(func()))
+	})
+	return _c
+}
+
+func (_c *MockWaylandContext_Post_Call) Return() *MockWaylandContext_Post_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockWaylandContext_Post_Call) RunAndReturn(run func(func())) *MockWaylandContext_Post_Call {
+	_c.Run(run)
+	return _c
+}
+
+// Start provides a mock function with no fields
+func (_m *MockWaylandContext) Start() {
+	_m.Called()
+}
+
+// MockWaylandContext_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
+type MockWaylandContext_Start_Call struct {
+	*mock.Call
+}
+
+// Start is a helper method to define mock.On call
+func (_e *MockWaylandContext_Expecter) Start() *MockWaylandContext_Start_Call {
+	return &MockWaylandContext_Start_Call{Call: _e.mock.On("Start")}
+}
+
+func (_c *MockWaylandContext_Start_Call) Run(run func()) *MockWaylandContext_Start_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockWaylandContext_Start_Call) Return() *MockWaylandContext_Start_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockWaylandContext_Start_Call) RunAndReturn(run func()) *MockWaylandContext_Start_Call {
+	_c.Run(run)
+	return _c
+}
+
+// NewMockWaylandContext creates a new instance of MockWaylandContext. 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 NewMockWaylandContext(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockWaylandContext {
+	mock := &MockWaylandContext{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}