diff --git a/.github/workflows/go-ci.yml b/.github/workflows/go-ci.yml
index 08e397ac..5fb756c8 100644
--- a/.github/workflows/go-ci.yml
+++ b/.github/workflows/go-ci.yml
@@ -42,9 +42,9 @@ jobs:
           fi
 
       - name: Run golangci-lint
-        uses: golangci/golangci-lint-action@v6
+        uses: golangci/golangci-lint-action@v9
         with:
-          version: latest
+          version: v2
           working-directory: core
 
       - name: Test
diff --git a/core/.golangci.yml b/core/.golangci.yml
index a3f65311..6e7a2984 100644
--- a/core/.golangci.yml
+++ b/core/.golangci.yml
@@ -1,77 +1,105 @@
-linters-settings:
-  errcheck:
-    check-type-assertions: false
-    check-blank: false
-    exclude-functions:
-      # Cleanup/destroy operations
-      - (io.Closer).Close
-      - (*os.File).Close
-      - (net.Conn).Close
-      - (*net.Conn).Close
-      # Signal handling
-      - (*os.Process).Signal
-      - (*os.Process).Kill
-      # DBus cleanup
-      - (*github.com/godbus/dbus/v5.Conn).RemoveMatchSignal
-      - (*github.com/godbus/dbus/v5.Conn).RemoveSignal
-      # Encoding to network connections (if conn is bad, nothing we can do)
-      - (*encoding/json.Encoder).Encode
-      - (net.Conn).Write
-      # Command execution where failure is expected/ignored
-      - (*os/exec.Cmd).Run
-      - (*os/exec.Cmd).Start
-      # Flush operations
-      - (*bufio.Writer).Flush
-      # Scanning user input
-      - fmt.Scanln
-      - fmt.Scanf
-      # Parse operations where default value is acceptable
-      - fmt.Sscanf
-      # Flag operations
-      - (*github.com/spf13/pflag.FlagSet).MarkHidden
-      # Binary encoding to buffer (can't fail for basic types)
-      - binary.Write
-      # File operations in cleanup paths
-      - os.Rename
-      - os.Remove
-      - (*os.File).WriteString
+version: "2"
 
-issues:
-  exclude-rules:
-    - path: _test\.go
-      linters:
-        - errcheck
-        - govet
-        - unused
-        - ineffassign
-        - staticcheck
-        - gosimple
-    # Exclude cleanup/teardown method calls from errcheck
-    - linters:
-        - errcheck
-      text: "Error return value of `.+\\.(Destroy|Release|Stop|Close|Roundtrip|Store)` is not checked"
-    # Exclude internal state update methods that are best-effort
-    - linters:
-        - errcheck
-      text: "Error return value of `[mb]\\.\\w*(update|initialize|recreate|acquire|enumerate|list|List|Ensure|refresh|Lock)\\w*` is not checked"
-    # Exclude SetMode on wayland power controls (best-effort)
-    - linters:
-        - errcheck
-      text: "Error return value of `.+\\.SetMode` is not checked"
-    # Exclude AddMatchSignal which is best-effort monitoring setup
-    - linters:
-        - errcheck
-      text: "Error return value of `.+\\.AddMatchSignal` is not checked"
-    # Exclude wayland pkg from errcheck and ineffassign (generated code patterns)
-    - linters:
-        - errcheck
-        - ineffassign
-      path: pkg/go-wayland/
-    # Exclude proto pkg from ineffassign (generated protocol code)
-    - linters:
-        - ineffassign
-      path: internal/proto/
-    # binary.Write to bytes.Buffer can't fail
-    - linters:
-        - errcheck
-      text: "Error return value of `binary\\.Write` is not checked"
+linters:
+  enable:
+    - revive
+
+  settings:
+    revive:
+      rules:
+        - name: use-any
+          severity: error
+    errcheck:
+      check-type-assertions: false
+      check-blank: false
+      exclude-functions:
+        # Cleanup/destroy operations
+        - (io.Closer).Close
+        - (*os.File).Close
+        - (net.Conn).Close
+        - (*net.Conn).Close
+        # Signal handling
+        - (*os.Process).Signal
+        - (*os.Process).Kill
+        # DBus cleanup
+        - (*github.com/godbus/dbus/v5.Conn).RemoveMatchSignal
+        - (*github.com/godbus/dbus/v5.Conn).RemoveSignal
+        # Encoding to network connections (if conn is bad, nothing we can do)
+        - (*encoding/json.Encoder).Encode
+        - (net.Conn).Write
+        # Command execution where failure is expected/ignored
+        - (*os/exec.Cmd).Run
+        - (*os/exec.Cmd).Start
+        # Flush operations
+        - (*bufio.Writer).Flush
+        # Scanning user input
+        - fmt.Scanln
+        - fmt.Scanf
+        # Parse operations where default value is acceptable
+        - fmt.Sscanf
+        # Flag operations
+        - (*github.com/spf13/pflag.FlagSet).MarkHidden
+        # Binary encoding to buffer (can't fail for basic types)
+        - binary.Write
+        # File operations in cleanup paths
+        - os.Rename
+        - os.Remove
+        - os.RemoveAll
+        - (*os.File).WriteString
+        # Stdout/stderr writes (can't meaningfully handle failure)
+        - fmt.Fprintln
+        - fmt.Fprintf
+        - fmt.Fprint
+        # Writing to pipes (if pipe is bad, nothing we can do)
+        - (*io.PipeWriter).Write
+        - (*os.File).Write
+
+  exclusions:
+    rules:
+      # Exclude generated mocks from all linters
+      - path: internal/mocks/
+        linters:
+          - errcheck
+          - govet
+          - unused
+          - ineffassign
+          - staticcheck
+          - gosimple
+          - revive
+      - path: _test\.go
+        linters:
+          - errcheck
+          - govet
+          - unused
+          - ineffassign
+          - staticcheck
+          - gosimple
+      # Exclude cleanup/teardown method calls from errcheck
+      - linters:
+          - errcheck
+        text: "Error return value of `.+\\.(Destroy|Release|Stop|Close|Roundtrip|Store)` is not checked"
+      # Exclude internal state update methods that are best-effort
+      - linters:
+          - errcheck
+        text: "Error return value of `[mb]\\.\\w*(update|initialize|recreate|acquire|enumerate|list|List|Ensure|refresh|Lock)\\w*` is not checked"
+      # Exclude SetMode on wayland power controls (best-effort)
+      - linters:
+          - errcheck
+        text: "Error return value of `.+\\.SetMode` is not checked"
+      # Exclude AddMatchSignal which is best-effort monitoring setup
+      - linters:
+          - errcheck
+        text: "Error return value of `.+\\.AddMatchSignal` is not checked"
+      # Exclude wayland pkg from errcheck and ineffassign (generated code patterns)
+      - linters:
+          - errcheck
+          - ineffassign
+        path: pkg/go-wayland/
+      # Exclude proto pkg from ineffassign (generated protocol code)
+      - linters:
+          - ineffassign
+        path: internal/proto/
+      # binary.Write to bytes.Buffer can't fail
+      - linters:
+          - errcheck
+        text: "Error return value of `binary\\.Write` is not checked"
diff --git a/core/cmd/dms/commands_open.go b/core/cmd/dms/commands_open.go
index ac98801b..a4c567b2 100644
--- a/core/cmd/dms/commands_open.go
+++ b/core/cmd/dms/commands_open.go
@@ -186,7 +186,7 @@ func runOpen(target string) {
 		}
 	}
 
-	params := map[string]interface{}{
+	params := map[string]any{
 		"target": actualTarget,
 	}
 
diff --git a/core/internal/log/filelogger.go b/core/internal/log/filelogger.go
index 29605508..389d38a1 100644
--- a/core/internal/log/filelogger.go
+++ b/core/internal/log/filelogger.go
@@ -64,7 +64,7 @@ func (l *FileLogger) writeToFile(message string) {
 	redacted := l.redactPassword(message)
 	timestamp := time.Now().Format("15:04:05.000")
 
-	l.writer.WriteString(fmt.Sprintf("[%s] %s\n", timestamp, redacted)) //nolint:errcheck
+	fmt.Fprintf(l.writer, "[%s] %s\n", timestamp, redacted)
 	l.writer.Flush()
 }
 
diff --git a/core/internal/log/log.go b/core/internal/log/log.go
index 2b26585c..6b3ede3c 100644
--- a/core/internal/log/log.go
+++ b/core/internal/log/log.go
@@ -104,13 +104,13 @@ func GetLogger() *Logger {
 
 // * Convenience wrappers
 
-func Debug(msg any, keyvals ...any)  { GetLogger().Logger.Debug(msg, keyvals...) }
-func Debugf(format string, v ...any) { GetLogger().Logger.Debugf(format, v...) }
-func Info(msg any, keyvals ...any)   { GetLogger().Logger.Info(msg, keyvals...) }
-func Infof(format string, v ...any)  { GetLogger().Logger.Infof(format, v...) }
-func Warn(msg any, keyvals ...any)   { GetLogger().Logger.Warn(msg, keyvals...) }
-func Warnf(format string, v ...any)  { GetLogger().Logger.Warnf(format, v...) }
-func Error(msg any, keyvals ...any)  { GetLogger().Logger.Error(msg, keyvals...) }
-func Errorf(format string, v ...any) { GetLogger().Logger.Errorf(format, v...) }
-func Fatal(msg any, keyvals ...any)  { GetLogger().Logger.Fatal(msg, keyvals...) }
-func Fatalf(format string, v ...any) { GetLogger().Logger.Fatalf(format, v...) }
+func Debug(msg any, keyvals ...any)  { GetLogger().Debug(msg, keyvals...) }
+func Debugf(format string, v ...any) { GetLogger().Debugf(format, v...) }
+func Info(msg any, keyvals ...any)   { GetLogger().Info(msg, keyvals...) }
+func Infof(format string, v ...any)  { GetLogger().Infof(format, v...) }
+func Warn(msg any, keyvals ...any)   { GetLogger().Warn(msg, keyvals...) }
+func Warnf(format string, v ...any)  { GetLogger().Warnf(format, v...) }
+func Error(msg any, keyvals ...any)  { GetLogger().Error(msg, keyvals...) }
+func Errorf(format string, v ...any) { GetLogger().Errorf(format, v...) }
+func Fatal(msg any, keyvals ...any)  { GetLogger().Fatal(msg, keyvals...) }
+func Fatalf(format string, v ...any) { GetLogger().Fatalf(format, v...) }
diff --git a/core/internal/mocks/cups/mock_CUPSClientInterface.go b/core/internal/mocks/cups/mock_CUPSClientInterface.go
index 9d9b6160..3c980747 100644
--- a/core/internal/mocks/cups/mock_CUPSClientInterface.go
+++ b/core/internal/mocks/cups/mock_CUPSClientInterface.go
@@ -141,7 +141,7 @@ type MockCUPSClientInterface_CancelAllJob_Call struct {
 // CancelAllJob is a helper method to define mock.On call
 //   - printer string
 //   - purge bool
-func (_e *MockCUPSClientInterface_Expecter) CancelAllJob(printer any, purge any) *MockCUPSClientInterface_CancelAllJob_Call {
+func (_e *MockCUPSClientInterface_Expecter) CancelAllJob(printer interface{}, purge interface{}) *MockCUPSClientInterface_CancelAllJob_Call {
 	return &MockCUPSClientInterface_CancelAllJob_Call{Call: _e.mock.On("CancelAllJob", printer, purge)}
 }
 
@@ -188,7 +188,7 @@ type MockCUPSClientInterface_CancelJob_Call struct {
 // CancelJob is a helper method to define mock.On call
 //   - jobID int
 //   - purge bool
-func (_e *MockCUPSClientInterface_Expecter) CancelJob(jobID any, purge any) *MockCUPSClientInterface_CancelJob_Call {
+func (_e *MockCUPSClientInterface_Expecter) CancelJob(jobID interface{}, purge interface{}) *MockCUPSClientInterface_CancelJob_Call {
 	return &MockCUPSClientInterface_CancelJob_Call{Call: _e.mock.On("CancelJob", jobID, purge)}
 }
 
@@ -558,7 +558,7 @@ type MockCUPSClientInterface_GetJobs_Call struct {
 //   - firstJobId int
 //   - limit int
 //   - attributes []string
-func (_e *MockCUPSClientInterface_Expecter) GetJobs(printer any, class any, whichJobs any, myJobs any, firstJobId any, limit any, attributes any) *MockCUPSClientInterface_GetJobs_Call {
+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)}
 }
 
@@ -673,7 +673,7 @@ type MockCUPSClientInterface_GetPrinters_Call struct {
 
 // GetPrinters is a helper method to define mock.On call
 //   - attributes []string
-func (_e *MockCUPSClientInterface_Expecter) GetPrinters(attributes any) *MockCUPSClientInterface_GetPrinters_Call {
+func (_e *MockCUPSClientInterface_Expecter) GetPrinters(attributes interface{}) *MockCUPSClientInterface_GetPrinters_Call {
 	return &MockCUPSClientInterface_GetPrinters_Call{Call: _e.mock.On("GetPrinters", attributes)}
 }
 
@@ -813,7 +813,7 @@ type MockCUPSClientInterface_PausePrinter_Call struct {
 
 // PausePrinter is a helper method to define mock.On call
 //   - printer string
-func (_e *MockCUPSClientInterface_Expecter) PausePrinter(printer any) *MockCUPSClientInterface_PausePrinter_Call {
+func (_e *MockCUPSClientInterface_Expecter) PausePrinter(printer interface{}) *MockCUPSClientInterface_PausePrinter_Call {
 	return &MockCUPSClientInterface_PausePrinter_Call{Call: _e.mock.On("PausePrinter", printer)}
 }
 
@@ -1009,7 +1009,7 @@ type MockCUPSClientInterface_ResumePrinter_Call struct {
 
 // ResumePrinter is a helper method to define mock.On call
 //   - printer string
-func (_e *MockCUPSClientInterface_Expecter) ResumePrinter(printer any) *MockCUPSClientInterface_ResumePrinter_Call {
+func (_e *MockCUPSClientInterface_Expecter) ResumePrinter(printer interface{}) *MockCUPSClientInterface_ResumePrinter_Call {
 	return &MockCUPSClientInterface_ResumePrinter_Call{Call: _e.mock.On("ResumePrinter", printer)}
 }
 
@@ -1069,7 +1069,7 @@ type MockCUPSClientInterface_SendRequest_Call struct {
 //   - url string
 //   - req *ipp.Request
 //   - additionalResponseData io.Writer
-func (_e *MockCUPSClientInterface_Expecter) SendRequest(url any, req any, additionalResponseData any) *MockCUPSClientInterface_SendRequest_Call {
+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)}
 }
 
diff --git a/core/internal/mocks/evdev/mock_EvdevDevice.go b/core/internal/mocks/evdev/mock_EvdevDevice.go
index 09578a16..4d54e3e5 100644
--- a/core/internal/mocks/evdev/mock_EvdevDevice.go
+++ b/core/internal/mocks/evdev/mock_EvdevDevice.go
@@ -259,7 +259,7 @@ type MockEvdevDevice_State_Call struct {
 
 // State is a helper method to define mock.On call
 //   - t go_evdev.EvType
-func (_e *MockEvdevDevice_Expecter) State(t any) *MockEvdevDevice_State_Call {
+func (_e *MockEvdevDevice_Expecter) State(t interface{}) *MockEvdevDevice_State_Call {
 	return &MockEvdevDevice_State_Call{Call: _e.mock.On("State", t)}
 }
 
@@ -285,8 +285,7 @@ func (_c *MockEvdevDevice_State_Call) RunAndReturn(run func(go_evdev.EvType) (go
 func NewMockEvdevDevice(t interface {
 	mock.TestingT
 	Cleanup(func())
-},
-) *MockEvdevDevice {
+}) *MockEvdevDevice {
 	mock := &MockEvdevDevice{}
 	mock.Mock.Test(t)
 
diff --git a/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_ActiveConnection.go b/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_ActiveConnection.go
index 40cc283c..a4e3344e 100644
--- a/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_ActiveConnection.go
+++ b/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_ActiveConnection.go
@@ -989,7 +989,7 @@ type MockActiveConnection_SubscribeState_Call struct {
 // SubscribeState is a helper method to define mock.On call
 //   - receiver chan gonetworkmanager.StateChange
 //   - exit chan struct{}
-func (_e *MockActiveConnection_Expecter) SubscribeState(receiver any, exit any) *MockActiveConnection_SubscribeState_Call {
+func (_e *MockActiveConnection_Expecter) SubscribeState(receiver interface{}, exit interface{}) *MockActiveConnection_SubscribeState_Call {
 	return &MockActiveConnection_SubscribeState_Call{Call: _e.mock.On("SubscribeState", receiver, exit)}
 }
 
diff --git a/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Connection.go b/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Connection.go
index da2d966b..84f59e1c 100644
--- a/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Connection.go
+++ b/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Connection.go
@@ -359,7 +359,7 @@ type MockConnection_GetSecrets_Call struct {
 
 // GetSecrets is a helper method to define mock.On call
 //   - settingName string
-func (_e *MockConnection_Expecter) GetSecrets(settingName any) *MockConnection_GetSecrets_Call {
+func (_e *MockConnection_Expecter) GetSecrets(settingName interface{}) *MockConnection_GetSecrets_Call {
 	return &MockConnection_GetSecrets_Call{Call: _e.mock.On("GetSecrets", settingName)}
 }
 
@@ -564,7 +564,7 @@ type MockConnection_Update_Call struct {
 
 // Update is a helper method to define mock.On call
 //   - settings gonetworkmanager.ConnectionSettings
-func (_e *MockConnection_Expecter) Update(settings any) *MockConnection_Update_Call {
+func (_e *MockConnection_Expecter) Update(settings interface{}) *MockConnection_Update_Call {
 	return &MockConnection_Update_Call{Call: _e.mock.On("Update", settings)}
 }
 
@@ -610,7 +610,7 @@ type MockConnection_UpdateUnsaved_Call struct {
 
 // UpdateUnsaved is a helper method to define mock.On call
 //   - settings gonetworkmanager.ConnectionSettings
-func (_e *MockConnection_Expecter) UpdateUnsaved(settings any) *MockConnection_UpdateUnsaved_Call {
+func (_e *MockConnection_Expecter) UpdateUnsaved(settings interface{}) *MockConnection_UpdateUnsaved_Call {
 	return &MockConnection_UpdateUnsaved_Call{Call: _e.mock.On("UpdateUnsaved", settings)}
 }
 
diff --git a/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Device.go b/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Device.go
index 66521e03..b2fc0b52 100644
--- a/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Device.go
+++ b/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Device.go
@@ -1463,7 +1463,7 @@ type MockDevice_Reapply_Call struct {
 //   - connection gonetworkmanager.Connection
 //   - versionId uint64
 //   - flags uint32
-func (_e *MockDevice_Expecter) Reapply(connection any, versionId any, flags any) *MockDevice_Reapply_Call {
+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)}
 }
 
@@ -1509,7 +1509,7 @@ type MockDevice_SetPropertyAutoConnect_Call struct {
 
 // SetPropertyAutoConnect is a helper method to define mock.On call
 //   - _a0 bool
-func (_e *MockDevice_Expecter) SetPropertyAutoConnect(_a0 any) *MockDevice_SetPropertyAutoConnect_Call {
+func (_e *MockDevice_Expecter) SetPropertyAutoConnect(_a0 interface{}) *MockDevice_SetPropertyAutoConnect_Call {
 	return &MockDevice_SetPropertyAutoConnect_Call{Call: _e.mock.On("SetPropertyAutoConnect", _a0)}
 }
 
@@ -1555,7 +1555,7 @@ type MockDevice_SetPropertyManaged_Call struct {
 
 // SetPropertyManaged is a helper method to define mock.On call
 //   - _a0 bool
-func (_e *MockDevice_Expecter) SetPropertyManaged(_a0 any) *MockDevice_SetPropertyManaged_Call {
+func (_e *MockDevice_Expecter) SetPropertyManaged(_a0 interface{}) *MockDevice_SetPropertyManaged_Call {
 	return &MockDevice_SetPropertyManaged_Call{Call: _e.mock.On("SetPropertyManaged", _a0)}
 }
 
@@ -1602,7 +1602,7 @@ type MockDevice_SubscribeState_Call struct {
 // SubscribeState is a helper method to define mock.On call
 //   - receiver chan gonetworkmanager.DeviceStateChange
 //   - exit chan struct{}
-func (_e *MockDevice_Expecter) SubscribeState(receiver any, exit any) *MockDevice_SubscribeState_Call {
+func (_e *MockDevice_Expecter) SubscribeState(receiver interface{}, exit interface{}) *MockDevice_SubscribeState_Call {
 	return &MockDevice_SubscribeState_Call{Call: _e.mock.On("SubscribeState", receiver, exit)}
 }
 
diff --git a/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_DeviceWireless.go b/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_DeviceWireless.go
index 339c71b0..d2d3f2d6 100644
--- a/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_DeviceWireless.go
+++ b/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_DeviceWireless.go
@@ -2021,7 +2021,7 @@ type MockDeviceWireless_Reapply_Call struct {
 //   - connection gonetworkmanager.Connection
 //   - versionId uint64
 //   - flags uint32
-func (_e *MockDeviceWireless_Expecter) Reapply(connection any, versionId any, flags any) *MockDeviceWireless_Reapply_Call {
+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)}
 }
 
@@ -2112,7 +2112,7 @@ type MockDeviceWireless_SetPropertyAutoConnect_Call struct {
 
 // SetPropertyAutoConnect is a helper method to define mock.On call
 //   - _a0 bool
-func (_e *MockDeviceWireless_Expecter) SetPropertyAutoConnect(_a0 any) *MockDeviceWireless_SetPropertyAutoConnect_Call {
+func (_e *MockDeviceWireless_Expecter) SetPropertyAutoConnect(_a0 interface{}) *MockDeviceWireless_SetPropertyAutoConnect_Call {
 	return &MockDeviceWireless_SetPropertyAutoConnect_Call{Call: _e.mock.On("SetPropertyAutoConnect", _a0)}
 }
 
@@ -2158,7 +2158,7 @@ type MockDeviceWireless_SetPropertyManaged_Call struct {
 
 // SetPropertyManaged is a helper method to define mock.On call
 //   - _a0 bool
-func (_e *MockDeviceWireless_Expecter) SetPropertyManaged(_a0 any) *MockDeviceWireless_SetPropertyManaged_Call {
+func (_e *MockDeviceWireless_Expecter) SetPropertyManaged(_a0 interface{}) *MockDeviceWireless_SetPropertyManaged_Call {
 	return &MockDeviceWireless_SetPropertyManaged_Call{Call: _e.mock.On("SetPropertyManaged", _a0)}
 }
 
@@ -2205,7 +2205,7 @@ type MockDeviceWireless_SubscribeState_Call struct {
 // SubscribeState is a helper method to define mock.On call
 //   - receiver chan gonetworkmanager.DeviceStateChange
 //   - exit chan struct{}
-func (_e *MockDeviceWireless_Expecter) SubscribeState(receiver any, exit any) *MockDeviceWireless_SubscribeState_Call {
+func (_e *MockDeviceWireless_Expecter) SubscribeState(receiver interface{}, exit interface{}) *MockDeviceWireless_SubscribeState_Call {
 	return &MockDeviceWireless_SubscribeState_Call{Call: _e.mock.On("SubscribeState", receiver, exit)}
 }
 
diff --git a/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_NetworkManager.go b/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_NetworkManager.go
index 61a14fae..e74ffb04 100644
--- a/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_NetworkManager.go
+++ b/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_NetworkManager.go
@@ -61,7 +61,7 @@ type MockNetworkManager_ActivateConnection_Call struct {
 //   - connection gonetworkmanager.Connection
 //   - device gonetworkmanager.Device
 //   - specificObject *dbus.Object
-func (_e *MockNetworkManager_Expecter) ActivateConnection(connection any, device any, specificObject any) *MockNetworkManager_ActivateConnection_Call {
+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)}
 }
 
@@ -121,7 +121,7 @@ type MockNetworkManager_ActivateWirelessConnection_Call struct {
 //   - connection gonetworkmanager.Connection
 //   - device gonetworkmanager.Device
 //   - accessPoint gonetworkmanager.AccessPoint
-func (_e *MockNetworkManager_Expecter) ActivateWirelessConnection(connection any, device any, accessPoint any) *MockNetworkManager_ActivateWirelessConnection_Call {
+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)}
 }
 
@@ -143,7 +143,7 @@ func (_c *MockNetworkManager_ActivateWirelessConnection_Call) RunAndReturn(run f
 }
 
 // AddAndActivateConnection provides a mock function with given fields: connection, device
-func (_m *MockNetworkManager) AddAndActivateConnection(connection map[string]map[string]any, device gonetworkmanager.Device) (gonetworkmanager.ActiveConnection, error) {
+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 {
@@ -152,10 +152,10 @@ func (_m *MockNetworkManager) AddAndActivateConnection(connection map[string]map
 
 	var r0 gonetworkmanager.ActiveConnection
 	var r1 error
-	if rf, ok := ret.Get(0).(func(map[string]map[string]any, gonetworkmanager.Device) (gonetworkmanager.ActiveConnection, error)); ok {
+	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]any, gonetworkmanager.Device) gonetworkmanager.ActiveConnection); ok {
+	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 {
@@ -163,7 +163,7 @@ func (_m *MockNetworkManager) AddAndActivateConnection(connection map[string]map
 		}
 	}
 
-	if rf, ok := ret.Get(1).(func(map[string]map[string]any, gonetworkmanager.Device) error); ok {
+	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)
@@ -178,15 +178,15 @@ type MockNetworkManager_AddAndActivateConnection_Call struct {
 }
 
 // AddAndActivateConnection is a helper method to define mock.On call
-//   - connection map[string]map[string]any
+//   - connection map[string]map[string]interface{}
 //   - device gonetworkmanager.Device
-func (_e *MockNetworkManager_Expecter) AddAndActivateConnection(connection any, device any) *MockNetworkManager_AddAndActivateConnection_Call {
+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]any, device gonetworkmanager.Device)) *MockNetworkManager_AddAndActivateConnection_Call {
+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]any), args[1].(gonetworkmanager.Device))
+		run(args[0].(map[string]map[string]interface{}), args[1].(gonetworkmanager.Device))
 	})
 	return _c
 }
@@ -196,13 +196,13 @@ func (_c *MockNetworkManager_AddAndActivateConnection_Call) Return(_a0 gonetwork
 	return _c
 }
 
-func (_c *MockNetworkManager_AddAndActivateConnection_Call) RunAndReturn(run func(map[string]map[string]any, gonetworkmanager.Device) (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_AddAndActivateConnection_Call {
+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]any, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error) {
+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 {
@@ -211,10 +211,10 @@ func (_m *MockNetworkManager) AddAndActivateWirelessConnection(connection map[st
 
 	var r0 gonetworkmanager.ActiveConnection
 	var r1 error
-	if rf, ok := ret.Get(0).(func(map[string]map[string]any, gonetworkmanager.Device, gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error)); ok {
+	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]any, gonetworkmanager.Device, gonetworkmanager.AccessPoint) gonetworkmanager.ActiveConnection); ok {
+	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 {
@@ -222,7 +222,7 @@ func (_m *MockNetworkManager) AddAndActivateWirelessConnection(connection map[st
 		}
 	}
 
-	if rf, ok := ret.Get(1).(func(map[string]map[string]any, gonetworkmanager.Device, gonetworkmanager.AccessPoint) error); ok {
+	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)
@@ -237,16 +237,16 @@ type MockNetworkManager_AddAndActivateWirelessConnection_Call struct {
 }
 
 // AddAndActivateWirelessConnection is a helper method to define mock.On call
-//   - connection map[string]map[string]any
+//   - connection map[string]map[string]interface{}
 //   - device gonetworkmanager.Device
 //   - accessPoint gonetworkmanager.AccessPoint
-func (_e *MockNetworkManager_Expecter) AddAndActivateWirelessConnection(connection any, device any, accessPoint any) *MockNetworkManager_AddAndActivateWirelessConnection_Call {
+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]any, device gonetworkmanager.Device, accessPoint gonetworkmanager.AccessPoint)) *MockNetworkManager_AddAndActivateWirelessConnection_Call {
+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]any), args[1].(gonetworkmanager.Device), args[2].(gonetworkmanager.AccessPoint))
+		run(args[0].(map[string]map[string]interface{}), args[1].(gonetworkmanager.Device), args[2].(gonetworkmanager.AccessPoint))
 	})
 	return _c
 }
@@ -256,7 +256,7 @@ func (_c *MockNetworkManager_AddAndActivateWirelessConnection_Call) Return(_a0 g
 	return _c
 }
 
-func (_c *MockNetworkManager_AddAndActivateWirelessConnection_Call) RunAndReturn(run func(map[string]map[string]any, gonetworkmanager.Device, gonetworkmanager.AccessPoint) (gonetworkmanager.ActiveConnection, error)) *MockNetworkManager_AddAndActivateWirelessConnection_Call {
+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
 }
@@ -332,7 +332,7 @@ type MockNetworkManager_CheckpointAdjustRollbackTimeout_Call struct {
 // CheckpointAdjustRollbackTimeout is a helper method to define mock.On call
 //   - checkpoint gonetworkmanager.Checkpoint
 //   - addTimeout uint32
-func (_e *MockNetworkManager_Expecter) CheckpointAdjustRollbackTimeout(checkpoint any, addTimeout any) *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call {
+func (_e *MockNetworkManager_Expecter) CheckpointAdjustRollbackTimeout(checkpoint interface{}, addTimeout interface{}) *MockNetworkManager_CheckpointAdjustRollbackTimeout_Call {
 	return &MockNetworkManager_CheckpointAdjustRollbackTimeout_Call{Call: _e.mock.On("CheckpointAdjustRollbackTimeout", checkpoint, addTimeout)}
 }
 
@@ -392,7 +392,7 @@ type MockNetworkManager_CheckpointCreate_Call struct {
 //   - devices []gonetworkmanager.Device
 //   - rollbackTimeout uint32
 //   - flags uint32
-func (_e *MockNetworkManager_Expecter) CheckpointCreate(devices any, rollbackTimeout any, flags any) *MockNetworkManager_CheckpointCreate_Call {
+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)}
 }
 
@@ -438,7 +438,7 @@ type MockNetworkManager_CheckpointDestroy_Call struct {
 
 // CheckpointDestroy is a helper method to define mock.On call
 //   - checkpoint gonetworkmanager.Checkpoint
-func (_e *MockNetworkManager_Expecter) CheckpointDestroy(checkpoint any) *MockNetworkManager_CheckpointDestroy_Call {
+func (_e *MockNetworkManager_Expecter) CheckpointDestroy(checkpoint interface{}) *MockNetworkManager_CheckpointDestroy_Call {
 	return &MockNetworkManager_CheckpointDestroy_Call{Call: _e.mock.On("CheckpointDestroy", checkpoint)}
 }
 
@@ -496,7 +496,7 @@ type MockNetworkManager_CheckpointRollback_Call struct {
 
 // CheckpointRollback is a helper method to define mock.On call
 //   - checkpoint gonetworkmanager.Checkpoint
-func (_e *MockNetworkManager_Expecter) CheckpointRollback(checkpoint any) *MockNetworkManager_CheckpointRollback_Call {
+func (_e *MockNetworkManager_Expecter) CheckpointRollback(checkpoint interface{}) *MockNetworkManager_CheckpointRollback_Call {
 	return &MockNetworkManager_CheckpointRollback_Call{Call: _e.mock.On("CheckpointRollback", checkpoint)}
 }
 
@@ -542,7 +542,7 @@ type MockNetworkManager_DeactivateConnection_Call struct {
 
 // DeactivateConnection is a helper method to define mock.On call
 //   - connection gonetworkmanager.ActiveConnection
-func (_e *MockNetworkManager_Expecter) DeactivateConnection(connection any) *MockNetworkManager_DeactivateConnection_Call {
+func (_e *MockNetworkManager_Expecter) DeactivateConnection(connection interface{}) *MockNetworkManager_DeactivateConnection_Call {
 	return &MockNetworkManager_DeactivateConnection_Call{Call: _e.mock.On("DeactivateConnection", connection)}
 }
 
@@ -588,7 +588,7 @@ type MockNetworkManager_Enable_Call struct {
 
 // Enable is a helper method to define mock.On call
 //   - enableNDisable bool
-func (_e *MockNetworkManager_Expecter) Enable(enableNDisable any) *MockNetworkManager_Enable_Call {
+func (_e *MockNetworkManager_Expecter) Enable(enableNDisable interface{}) *MockNetworkManager_Enable_Call {
 	return &MockNetworkManager_Enable_Call{Call: _e.mock.On("Enable", enableNDisable)}
 }
 
@@ -703,7 +703,7 @@ type MockNetworkManager_GetDeviceByIpIface_Call struct {
 
 // GetDeviceByIpIface is a helper method to define mock.On call
 //   - interfaceId string
-func (_e *MockNetworkManager_Expecter) GetDeviceByIpIface(interfaceId any) *MockNetworkManager_GetDeviceByIpIface_Call {
+func (_e *MockNetworkManager_Expecter) GetDeviceByIpIface(interfaceId interface{}) *MockNetworkManager_GetDeviceByIpIface_Call {
 	return &MockNetworkManager_GetDeviceByIpIface_Call{Call: _e.mock.On("GetDeviceByIpIface", interfaceId)}
 }
 
@@ -2087,7 +2087,7 @@ type MockNetworkManager_Reload_Call struct {
 
 // Reload is a helper method to define mock.On call
 //   - flags uint32
-func (_e *MockNetworkManager_Expecter) Reload(flags any) *MockNetworkManager_Reload_Call {
+func (_e *MockNetworkManager_Expecter) Reload(flags interface{}) *MockNetworkManager_Reload_Call {
 	return &MockNetworkManager_Reload_Call{Call: _e.mock.On("Reload", flags)}
 }
 
@@ -2133,7 +2133,7 @@ type MockNetworkManager_SetPropertyWirelessEnabled_Call struct {
 
 // SetPropertyWirelessEnabled is a helper method to define mock.On call
 //   - _a0 bool
-func (_e *MockNetworkManager_Expecter) SetPropertyWirelessEnabled(_a0 any) *MockNetworkManager_SetPropertyWirelessEnabled_Call {
+func (_e *MockNetworkManager_Expecter) SetPropertyWirelessEnabled(_a0 interface{}) *MockNetworkManager_SetPropertyWirelessEnabled_Call {
 	return &MockNetworkManager_SetPropertyWirelessEnabled_Call{Call: _e.mock.On("SetPropertyWirelessEnabled", _a0)}
 }
 
@@ -2179,7 +2179,7 @@ type MockNetworkManager_Sleep_Call struct {
 
 // Sleep is a helper method to define mock.On call
 //   - sleepNWake bool
-func (_e *MockNetworkManager_Expecter) Sleep(sleepNWake any) *MockNetworkManager_Sleep_Call {
+func (_e *MockNetworkManager_Expecter) Sleep(sleepNWake interface{}) *MockNetworkManager_Sleep_Call {
 	return &MockNetworkManager_Sleep_Call{Call: _e.mock.On("Sleep", sleepNWake)}
 }
 
diff --git a/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Settings.go b/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Settings.go
index 7e10adb5..20f488ef 100644
--- a/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Settings.go
+++ b/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Settings.go
@@ -57,7 +57,7 @@ type MockSettings_AddConnection_Call struct {
 
 // AddConnection is a helper method to define mock.On call
 //   - settings gonetworkmanager.ConnectionSettings
-func (_e *MockSettings_Expecter) AddConnection(settings any) *MockSettings_AddConnection_Call {
+func (_e *MockSettings_Expecter) AddConnection(settings interface{}) *MockSettings_AddConnection_Call {
 	return &MockSettings_AddConnection_Call{Call: _e.mock.On("AddConnection", settings)}
 }
 
@@ -115,7 +115,7 @@ type MockSettings_AddConnectionUnsaved_Call struct {
 
 // AddConnectionUnsaved is a helper method to define mock.On call
 //   - settings gonetworkmanager.ConnectionSettings
-func (_e *MockSettings_Expecter) AddConnectionUnsaved(settings any) *MockSettings_AddConnectionUnsaved_Call {
+func (_e *MockSettings_Expecter) AddConnectionUnsaved(settings interface{}) *MockSettings_AddConnectionUnsaved_Call {
 	return &MockSettings_AddConnectionUnsaved_Call{Call: _e.mock.On("AddConnectionUnsaved", settings)}
 }
 
@@ -173,7 +173,7 @@ type MockSettings_GetConnectionByUUID_Call struct {
 
 // GetConnectionByUUID is a helper method to define mock.On call
 //   - uuid string
-func (_e *MockSettings_Expecter) GetConnectionByUUID(uuid any) *MockSettings_GetConnectionByUUID_Call {
+func (_e *MockSettings_Expecter) GetConnectionByUUID(uuid interface{}) *MockSettings_GetConnectionByUUID_Call {
 	return &MockSettings_GetConnectionByUUID_Call{Call: _e.mock.On("GetConnectionByUUID", uuid)}
 }
 
@@ -431,7 +431,7 @@ type MockSettings_SaveHostname_Call struct {
 
 // SaveHostname is a helper method to define mock.On call
 //   - hostname string
-func (_e *MockSettings_Expecter) SaveHostname(hostname any) *MockSettings_SaveHostname_Call {
+func (_e *MockSettings_Expecter) SaveHostname(hostname interface{}) *MockSettings_SaveHostname_Call {
 	return &MockSettings_SaveHostname_Call{Call: _e.mock.On("SaveHostname", hostname)}
 }
 
diff --git a/core/internal/mocks/github.com/godbus/dbus/v5/mock_BusObject.go b/core/internal/mocks/github.com/godbus/dbus/v5/mock_BusObject.go
index e6778409..c0d1a3fa 100644
--- a/core/internal/mocks/github.com/godbus/dbus/v5/mock_BusObject.go
+++ b/core/internal/mocks/github.com/godbus/dbus/v5/mock_BusObject.go
@@ -24,11 +24,11 @@ func (_m *MockBusObject) EXPECT() *MockBusObject_Expecter {
 
 // 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([]any, len(options))
+	_va := make([]interface{}, len(options))
 	for _i := range options {
 		_va[_i] = options[_i]
 	}
-	var _ca []any
+	var _ca []interface{}
 	_ca = append(_ca, iface, member)
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
@@ -58,9 +58,9 @@ type MockBusObject_AddMatchSignal_Call struct {
 //   - iface string
 //   - member string
 //   - options ...dbus.MatchOption
-func (_e *MockBusObject_Expecter) AddMatchSignal(iface any, member any, options ...any) *MockBusObject_AddMatchSignal_Call {
+func (_e *MockBusObject_Expecter) AddMatchSignal(iface interface{}, member interface{}, options ...interface{}) *MockBusObject_AddMatchSignal_Call {
 	return &MockBusObject_AddMatchSignal_Call{Call: _e.mock.On("AddMatchSignal",
-		append([]any{iface, member}, options...)...)}
+		append([]interface{}{iface, member}, options...)...)}
 }
 
 func (_c *MockBusObject_AddMatchSignal_Call) Run(run func(iface string, member string, options ...dbus.MatchOption)) *MockBusObject_AddMatchSignal_Call {
@@ -87,8 +87,8 @@ func (_c *MockBusObject_AddMatchSignal_Call) RunAndReturn(run func(string, strin
 }
 
 // Call provides a mock function with given fields: method, flags, args
-func (_m *MockBusObject) Call(method string, flags dbus.Flags, args ...any) *dbus.Call {
-	var _ca []any
+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...)
@@ -98,7 +98,7 @@ func (_m *MockBusObject) Call(method string, flags dbus.Flags, args ...any) *dbu
 	}
 
 	var r0 *dbus.Call
-	if rf, ok := ret.Get(0).(func(string, dbus.Flags, ...any) *dbus.Call); ok {
+	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 {
@@ -117,18 +117,18 @@ type MockBusObject_Call_Call struct {
 // Call is a helper method to define mock.On call
 //   - method string
 //   - flags dbus.Flags
-//   - args ...any
-func (_e *MockBusObject_Expecter) Call(method any, flags any, args ...any) *MockBusObject_Call_Call {
+//   - 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([]any{method, flags}, args...)...)}
+		append([]interface{}{method, flags}, args...)...)}
 }
 
-func (_c *MockBusObject_Call_Call) Run(run func(method string, flags dbus.Flags, args ...any)) *MockBusObject_Call_Call {
+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([]any, len(args)-2)
+		variadicArgs := make([]interface{}, len(args)-2)
 		for i, a := range args[2:] {
 			if a != nil {
-				variadicArgs[i] = a.(any)
+				variadicArgs[i] = a.(interface{})
 			}
 		}
 		run(args[0].(string), args[1].(dbus.Flags), variadicArgs...)
@@ -141,14 +141,14 @@ func (_c *MockBusObject_Call_Call) Return(_a0 *dbus.Call) *MockBusObject_Call_Ca
 	return _c
 }
 
-func (_c *MockBusObject_Call_Call) RunAndReturn(run func(string, dbus.Flags, ...any) *dbus.Call) *MockBusObject_Call_Call {
+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 ...any) *dbus.Call {
-	var _ca []any
+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...)
@@ -158,7 +158,7 @@ func (_m *MockBusObject) CallWithContext(ctx context.Context, method string, fla
 	}
 
 	var r0 *dbus.Call
-	if rf, ok := ret.Get(0).(func(context.Context, string, dbus.Flags, ...any) *dbus.Call); ok {
+	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 {
@@ -178,18 +178,18 @@ type MockBusObject_CallWithContext_Call struct {
 //   - ctx context.Context
 //   - method string
 //   - flags dbus.Flags
-//   - args ...any
-func (_e *MockBusObject_Expecter) CallWithContext(ctx any, method any, flags any, args ...any) *MockBusObject_CallWithContext_Call {
+//   - 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([]any{ctx, method, flags}, args...)...)}
+		append([]interface{}{ctx, method, flags}, args...)...)}
 }
 
-func (_c *MockBusObject_CallWithContext_Call) Run(run func(ctx context.Context, method string, flags dbus.Flags, args ...any)) *MockBusObject_CallWithContext_Call {
+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([]any, len(args)-3)
+		variadicArgs := make([]interface{}, len(args)-3)
 		for i, a := range args[3:] {
 			if a != nil {
-				variadicArgs[i] = a.(any)
+				variadicArgs[i] = a.(interface{})
 			}
 		}
 		run(args[0].(context.Context), args[1].(string), args[2].(dbus.Flags), variadicArgs...)
@@ -202,7 +202,7 @@ func (_c *MockBusObject_CallWithContext_Call) Return(_a0 *dbus.Call) *MockBusObj
 	return _c
 }
 
-func (_c *MockBusObject_CallWithContext_Call) RunAndReturn(run func(context.Context, string, dbus.Flags, ...any) *dbus.Call) *MockBusObject_CallWithContext_Call {
+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
 }
@@ -287,7 +287,7 @@ type MockBusObject_GetProperty_Call struct {
 
 // GetProperty is a helper method to define mock.On call
 //   - p string
-func (_e *MockBusObject_Expecter) GetProperty(p any) *MockBusObject_GetProperty_Call {
+func (_e *MockBusObject_Expecter) GetProperty(p interface{}) *MockBusObject_GetProperty_Call {
 	return &MockBusObject_GetProperty_Call{Call: _e.mock.On("GetProperty", p)}
 }
 
@@ -309,8 +309,8 @@ func (_c *MockBusObject_GetProperty_Call) RunAndReturn(run func(string) (dbus.Va
 }
 
 // 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 ...any) *dbus.Call {
-	var _ca []any
+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...)
@@ -320,7 +320,7 @@ func (_m *MockBusObject) Go(method string, flags dbus.Flags, ch chan *dbus.Call,
 	}
 
 	var r0 *dbus.Call
-	if rf, ok := ret.Get(0).(func(string, dbus.Flags, chan *dbus.Call, ...any) *dbus.Call); ok {
+	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 {
@@ -340,18 +340,18 @@ type MockBusObject_Go_Call struct {
 //   - method string
 //   - flags dbus.Flags
 //   - ch chan *dbus.Call
-//   - args ...any
-func (_e *MockBusObject_Expecter) Go(method any, flags any, ch any, args ...any) *MockBusObject_Go_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([]any{method, flags, ch}, args...)...)}
+		append([]interface{}{method, flags, ch}, args...)...)}
 }
 
-func (_c *MockBusObject_Go_Call) Run(run func(method string, flags dbus.Flags, ch chan *dbus.Call, args ...any)) *MockBusObject_Go_Call {
+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([]any, len(args)-3)
+		variadicArgs := make([]interface{}, len(args)-3)
 		for i, a := range args[3:] {
 			if a != nil {
-				variadicArgs[i] = a.(any)
+				variadicArgs[i] = a.(interface{})
 			}
 		}
 		run(args[0].(string), args[1].(dbus.Flags), args[2].(chan *dbus.Call), variadicArgs...)
@@ -364,14 +364,14 @@ func (_c *MockBusObject_Go_Call) Return(_a0 *dbus.Call) *MockBusObject_Go_Call {
 	return _c
 }
 
-func (_c *MockBusObject_Go_Call) RunAndReturn(run func(string, dbus.Flags, chan *dbus.Call, ...any) *dbus.Call) *MockBusObject_Go_Call {
+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 ...any) *dbus.Call {
-	var _ca []any
+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...)
@@ -381,7 +381,7 @@ func (_m *MockBusObject) GoWithContext(ctx context.Context, method string, flags
 	}
 
 	var r0 *dbus.Call
-	if rf, ok := ret.Get(0).(func(context.Context, string, dbus.Flags, chan *dbus.Call, ...any) *dbus.Call); ok {
+	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 {
@@ -402,18 +402,18 @@ type MockBusObject_GoWithContext_Call struct {
 //   - method string
 //   - flags dbus.Flags
 //   - ch chan *dbus.Call
-//   - args ...any
-func (_e *MockBusObject_Expecter) GoWithContext(ctx any, method any, flags any, ch any, args ...any) *MockBusObject_GoWithContext_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([]any{ctx, method, flags, ch}, args...)...)}
+		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 ...any)) *MockBusObject_GoWithContext_Call {
+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([]any, len(args)-4)
+		variadicArgs := make([]interface{}, len(args)-4)
 		for i, a := range args[4:] {
 			if a != nil {
-				variadicArgs[i] = a.(any)
+				variadicArgs[i] = a.(interface{})
 			}
 		}
 		run(args[0].(context.Context), args[1].(string), args[2].(dbus.Flags), args[3].(chan *dbus.Call), variadicArgs...)
@@ -426,7 +426,7 @@ func (_c *MockBusObject_GoWithContext_Call) Return(_a0 *dbus.Call) *MockBusObjec
 	return _c
 }
 
-func (_c *MockBusObject_GoWithContext_Call) RunAndReturn(run func(context.Context, string, dbus.Flags, chan *dbus.Call, ...any) *dbus.Call) *MockBusObject_GoWithContext_Call {
+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
 }
@@ -478,11 +478,11 @@ func (_c *MockBusObject_Path_Call) RunAndReturn(run func() dbus.ObjectPath) *Moc
 
 // 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([]any, len(options))
+	_va := make([]interface{}, len(options))
 	for _i := range options {
 		_va[_i] = options[_i]
 	}
-	var _ca []any
+	var _ca []interface{}
 	_ca = append(_ca, iface, member)
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
@@ -512,9 +512,9 @@ type MockBusObject_RemoveMatchSignal_Call struct {
 //   - iface string
 //   - member string
 //   - options ...dbus.MatchOption
-func (_e *MockBusObject_Expecter) RemoveMatchSignal(iface any, member any, options ...any) *MockBusObject_RemoveMatchSignal_Call {
+func (_e *MockBusObject_Expecter) RemoveMatchSignal(iface interface{}, member interface{}, options ...interface{}) *MockBusObject_RemoveMatchSignal_Call {
 	return &MockBusObject_RemoveMatchSignal_Call{Call: _e.mock.On("RemoveMatchSignal",
-		append([]any{iface, member}, options...)...)}
+		append([]interface{}{iface, member}, options...)...)}
 }
 
 func (_c *MockBusObject_RemoveMatchSignal_Call) Run(run func(iface string, member string, options ...dbus.MatchOption)) *MockBusObject_RemoveMatchSignal_Call {
@@ -541,7 +541,7 @@ func (_c *MockBusObject_RemoveMatchSignal_Call) RunAndReturn(run func(string, st
 }
 
 // SetProperty provides a mock function with given fields: p, v
-func (_m *MockBusObject) SetProperty(p string, v any) error {
+func (_m *MockBusObject) SetProperty(p string, v interface{}) error {
 	ret := _m.Called(p, v)
 
 	if len(ret) == 0 {
@@ -549,7 +549,7 @@ func (_m *MockBusObject) SetProperty(p string, v any) error {
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(string, any) error); ok {
+	if rf, ok := ret.Get(0).(func(string, interface{}) error); ok {
 		r0 = rf(p, v)
 	} else {
 		r0 = ret.Error(0)
@@ -565,14 +565,14 @@ type MockBusObject_SetProperty_Call struct {
 
 // SetProperty is a helper method to define mock.On call
 //   - p string
-//   - v any
-func (_e *MockBusObject_Expecter) SetProperty(p any, v any) *MockBusObject_SetProperty_Call {
+//   - 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 any)) *MockBusObject_SetProperty_Call {
+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].(any))
+		run(args[0].(string), args[1].(interface{}))
 	})
 	return _c
 }
@@ -582,13 +582,13 @@ func (_c *MockBusObject_SetProperty_Call) Return(_a0 error) *MockBusObject_SetPr
 	return _c
 }
 
-func (_c *MockBusObject_SetProperty_Call) RunAndReturn(run func(string, any) error) *MockBusObject_SetProperty_Call {
+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 any) error {
+func (_m *MockBusObject) StoreProperty(p string, value interface{}) error {
 	ret := _m.Called(p, value)
 
 	if len(ret) == 0 {
@@ -596,7 +596,7 @@ func (_m *MockBusObject) StoreProperty(p string, value any) error {
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(string, any) error); ok {
+	if rf, ok := ret.Get(0).(func(string, interface{}) error); ok {
 		r0 = rf(p, value)
 	} else {
 		r0 = ret.Error(0)
@@ -612,14 +612,14 @@ type MockBusObject_StoreProperty_Call struct {
 
 // StoreProperty is a helper method to define mock.On call
 //   - p string
-//   - value any
-func (_e *MockBusObject_Expecter) StoreProperty(p any, value any) *MockBusObject_StoreProperty_Call {
+//   - 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 any)) *MockBusObject_StoreProperty_Call {
+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].(any))
+		run(args[0].(string), args[1].(interface{}))
 	})
 	return _c
 }
@@ -629,7 +629,7 @@ func (_c *MockBusObject_StoreProperty_Call) Return(_a0 error) *MockBusObject_Sto
 	return _c
 }
 
-func (_c *MockBusObject_StoreProperty_Call) RunAndReturn(run func(string, any) error) *MockBusObject_StoreProperty_Call {
+func (_c *MockBusObject_StoreProperty_Call) RunAndReturn(run func(string, interface{}) error) *MockBusObject_StoreProperty_Call {
 	_c.Call.Return(run)
 	return _c
 }
diff --git a/core/internal/mocks/net/mock_Conn.go b/core/internal/mocks/net/mock_Conn.go
index f48694fa..248a0d8a 100644
--- a/core/internal/mocks/net/mock_Conn.go
+++ b/core/internal/mocks/net/mock_Conn.go
@@ -150,7 +150,7 @@ type MockConn_Read_Call struct {
 
 // Read is a helper method to define mock.On call
 //   - b []byte
-func (_e *MockConn_Expecter) Read(b any) *MockConn_Read_Call {
+func (_e *MockConn_Expecter) Read(b interface{}) *MockConn_Read_Call {
 	return &MockConn_Read_Call{Call: _e.mock.On("Read", b)}
 }
 
@@ -243,7 +243,7 @@ type MockConn_SetDeadline_Call struct {
 
 // SetDeadline is a helper method to define mock.On call
 //   - t time.Time
-func (_e *MockConn_Expecter) SetDeadline(t any) *MockConn_SetDeadline_Call {
+func (_e *MockConn_Expecter) SetDeadline(t interface{}) *MockConn_SetDeadline_Call {
 	return &MockConn_SetDeadline_Call{Call: _e.mock.On("SetDeadline", t)}
 }
 
@@ -289,7 +289,7 @@ type MockConn_SetReadDeadline_Call struct {
 
 // SetReadDeadline is a helper method to define mock.On call
 //   - t time.Time
-func (_e *MockConn_Expecter) SetReadDeadline(t any) *MockConn_SetReadDeadline_Call {
+func (_e *MockConn_Expecter) SetReadDeadline(t interface{}) *MockConn_SetReadDeadline_Call {
 	return &MockConn_SetReadDeadline_Call{Call: _e.mock.On("SetReadDeadline", t)}
 }
 
@@ -335,7 +335,7 @@ type MockConn_SetWriteDeadline_Call struct {
 
 // SetWriteDeadline is a helper method to define mock.On call
 //   - t time.Time
-func (_e *MockConn_Expecter) SetWriteDeadline(t any) *MockConn_SetWriteDeadline_Call {
+func (_e *MockConn_Expecter) SetWriteDeadline(t interface{}) *MockConn_SetWriteDeadline_Call {
 	return &MockConn_SetWriteDeadline_Call{Call: _e.mock.On("SetWriteDeadline", t)}
 }
 
@@ -391,7 +391,7 @@ type MockConn_Write_Call struct {
 
 // Write is a helper method to define mock.On call
 //   - b []byte
-func (_e *MockConn_Expecter) Write(b any) *MockConn_Write_Call {
+func (_e *MockConn_Expecter) Write(b interface{}) *MockConn_Write_Call {
 	return &MockConn_Write_Call{Call: _e.mock.On("Write", b)}
 }
 
diff --git a/core/internal/mocks/network/mock_Backend.go b/core/internal/mocks/network/mock_Backend.go
index f45c5bf6..a4db08b9 100644
--- a/core/internal/mocks/network/mock_Backend.go
+++ b/core/internal/mocks/network/mock_Backend.go
@@ -45,7 +45,7 @@ type MockBackend_ActivateWiredConnection_Call struct {
 
 // ActivateWiredConnection is a helper method to define mock.On call
 //   - uuid string
-func (_e *MockBackend_Expecter) ActivateWiredConnection(uuid any) *MockBackend_ActivateWiredConnection_Call {
+func (_e *MockBackend_Expecter) ActivateWiredConnection(uuid interface{}) *MockBackend_ActivateWiredConnection_Call {
 	return &MockBackend_ActivateWiredConnection_Call{Call: _e.mock.On("ActivateWiredConnection", uuid)}
 }
 
@@ -91,7 +91,7 @@ type MockBackend_CancelCredentials_Call struct {
 
 // CancelCredentials is a helper method to define mock.On call
 //   - token string
-func (_e *MockBackend_Expecter) CancelCredentials(token any) *MockBackend_CancelCredentials_Call {
+func (_e *MockBackend_Expecter) CancelCredentials(token interface{}) *MockBackend_CancelCredentials_Call {
 	return &MockBackend_CancelCredentials_Call{Call: _e.mock.On("CancelCredentials", token)}
 }
 
@@ -137,7 +137,7 @@ type MockBackend_ClearVPNCredentials_Call struct {
 
 // ClearVPNCredentials is a helper method to define mock.On call
 //   - uuidOrName string
-func (_e *MockBackend_Expecter) ClearVPNCredentials(uuidOrName any) *MockBackend_ClearVPNCredentials_Call {
+func (_e *MockBackend_Expecter) ClearVPNCredentials(uuidOrName interface{}) *MockBackend_ClearVPNCredentials_Call {
 	return &MockBackend_ClearVPNCredentials_Call{Call: _e.mock.On("ClearVPNCredentials", uuidOrName)}
 }
 
@@ -261,7 +261,7 @@ type MockBackend_ConnectVPN_Call struct {
 // ConnectVPN is a helper method to define mock.On call
 //   - uuidOrName string
 //   - singleActive bool
-func (_e *MockBackend_Expecter) ConnectVPN(uuidOrName any, singleActive any) *MockBackend_ConnectVPN_Call {
+func (_e *MockBackend_Expecter) ConnectVPN(uuidOrName interface{}, singleActive interface{}) *MockBackend_ConnectVPN_Call {
 	return &MockBackend_ConnectVPN_Call{Call: _e.mock.On("ConnectVPN", uuidOrName, singleActive)}
 }
 
@@ -307,7 +307,7 @@ type MockBackend_ConnectWiFi_Call struct {
 
 // ConnectWiFi is a helper method to define mock.On call
 //   - req network.ConnectionRequest
-func (_e *MockBackend_Expecter) ConnectWiFi(req any) *MockBackend_ConnectWiFi_Call {
+func (_e *MockBackend_Expecter) ConnectWiFi(req interface{}) *MockBackend_ConnectWiFi_Call {
 	return &MockBackend_ConnectWiFi_Call{Call: _e.mock.On("ConnectWiFi", req)}
 }
 
@@ -353,7 +353,7 @@ type MockBackend_DeleteVPN_Call struct {
 
 // DeleteVPN is a helper method to define mock.On call
 //   - uuidOrName string
-func (_e *MockBackend_Expecter) DeleteVPN(uuidOrName any) *MockBackend_DeleteVPN_Call {
+func (_e *MockBackend_Expecter) DeleteVPN(uuidOrName interface{}) *MockBackend_DeleteVPN_Call {
 	return &MockBackend_DeleteVPN_Call{Call: _e.mock.On("DeleteVPN", uuidOrName)}
 }
 
@@ -489,7 +489,7 @@ type MockBackend_DisconnectEthernetDevice_Call struct {
 
 // DisconnectEthernetDevice is a helper method to define mock.On call
 //   - device string
-func (_e *MockBackend_Expecter) DisconnectEthernetDevice(device any) *MockBackend_DisconnectEthernetDevice_Call {
+func (_e *MockBackend_Expecter) DisconnectEthernetDevice(device interface{}) *MockBackend_DisconnectEthernetDevice_Call {
 	return &MockBackend_DisconnectEthernetDevice_Call{Call: _e.mock.On("DisconnectEthernetDevice", device)}
 }
 
@@ -535,7 +535,7 @@ type MockBackend_DisconnectVPN_Call struct {
 
 // DisconnectVPN is a helper method to define mock.On call
 //   - uuidOrName string
-func (_e *MockBackend_Expecter) DisconnectVPN(uuidOrName any) *MockBackend_DisconnectVPN_Call {
+func (_e *MockBackend_Expecter) DisconnectVPN(uuidOrName interface{}) *MockBackend_DisconnectVPN_Call {
 	return &MockBackend_DisconnectVPN_Call{Call: _e.mock.On("DisconnectVPN", uuidOrName)}
 }
 
@@ -626,7 +626,7 @@ type MockBackend_DisconnectWiFiDevice_Call struct {
 
 // DisconnectWiFiDevice is a helper method to define mock.On call
 //   - device string
-func (_e *MockBackend_Expecter) DisconnectWiFiDevice(device any) *MockBackend_DisconnectWiFiDevice_Call {
+func (_e *MockBackend_Expecter) DisconnectWiFiDevice(device interface{}) *MockBackend_DisconnectWiFiDevice_Call {
 	return &MockBackend_DisconnectWiFiDevice_Call{Call: _e.mock.On("DisconnectWiFiDevice", device)}
 }
 
@@ -672,7 +672,7 @@ type MockBackend_ForgetWiFiNetwork_Call struct {
 
 // ForgetWiFiNetwork is a helper method to define mock.On call
 //   - ssid string
-func (_e *MockBackend_Expecter) ForgetWiFiNetwork(ssid any) *MockBackend_ForgetWiFiNetwork_Call {
+func (_e *MockBackend_Expecter) ForgetWiFiNetwork(ssid interface{}) *MockBackend_ForgetWiFiNetwork_Call {
 	return &MockBackend_ForgetWiFiNetwork_Call{Call: _e.mock.On("ForgetWiFiNetwork", ssid)}
 }
 
@@ -881,7 +881,7 @@ type MockBackend_GetVPNConfig_Call struct {
 
 // GetVPNConfig is a helper method to define mock.On call
 //   - uuidOrName string
-func (_e *MockBackend_Expecter) GetVPNConfig(uuidOrName any) *MockBackend_GetVPNConfig_Call {
+func (_e *MockBackend_Expecter) GetVPNConfig(uuidOrName interface{}) *MockBackend_GetVPNConfig_Call {
 	return &MockBackend_GetVPNConfig_Call{Call: _e.mock.On("GetVPNConfig", uuidOrName)}
 }
 
@@ -1041,7 +1041,7 @@ type MockBackend_GetWiFiNetworkDetails_Call struct {
 
 // GetWiFiNetworkDetails is a helper method to define mock.On call
 //   - ssid string
-func (_e *MockBackend_Expecter) GetWiFiNetworkDetails(ssid any) *MockBackend_GetWiFiNetworkDetails_Call {
+func (_e *MockBackend_Expecter) GetWiFiNetworkDetails(ssid interface{}) *MockBackend_GetWiFiNetworkDetails_Call {
 	return &MockBackend_GetWiFiNetworkDetails_Call{Call: _e.mock.On("GetWiFiNetworkDetails", ssid)}
 }
 
@@ -1156,7 +1156,7 @@ type MockBackend_GetWiredNetworkDetails_Call struct {
 
 // GetWiredNetworkDetails is a helper method to define mock.On call
 //   - uuid string
-func (_e *MockBackend_Expecter) GetWiredNetworkDetails(uuid any) *MockBackend_GetWiredNetworkDetails_Call {
+func (_e *MockBackend_Expecter) GetWiredNetworkDetails(uuid interface{}) *MockBackend_GetWiredNetworkDetails_Call {
 	return &MockBackend_GetWiredNetworkDetails_Call{Call: _e.mock.On("GetWiredNetworkDetails", uuid)}
 }
 
@@ -1215,7 +1215,7 @@ type MockBackend_ImportVPN_Call struct {
 // ImportVPN is a helper method to define mock.On call
 //   - filePath string
 //   - name string
-func (_e *MockBackend_Expecter) ImportVPN(filePath any, name any) *MockBackend_ImportVPN_Call {
+func (_e *MockBackend_Expecter) ImportVPN(filePath interface{}, name interface{}) *MockBackend_ImportVPN_Call {
 	return &MockBackend_ImportVPN_Call{Call: _e.mock.On("ImportVPN", filePath, name)}
 }
 
@@ -1522,7 +1522,7 @@ type MockBackend_ScanWiFiDevice_Call struct {
 
 // ScanWiFiDevice is a helper method to define mock.On call
 //   - device string
-func (_e *MockBackend_Expecter) ScanWiFiDevice(device any) *MockBackend_ScanWiFiDevice_Call {
+func (_e *MockBackend_Expecter) ScanWiFiDevice(device interface{}) *MockBackend_ScanWiFiDevice_Call {
 	return &MockBackend_ScanWiFiDevice_Call{Call: _e.mock.On("ScanWiFiDevice", device)}
 }
 
@@ -1568,7 +1568,7 @@ type MockBackend_SetPromptBroker_Call struct {
 
 // SetPromptBroker is a helper method to define mock.On call
 //   - broker network.PromptBroker
-func (_e *MockBackend_Expecter) SetPromptBroker(broker any) *MockBackend_SetPromptBroker_Call {
+func (_e *MockBackend_Expecter) SetPromptBroker(broker interface{}) *MockBackend_SetPromptBroker_Call {
 	return &MockBackend_SetPromptBroker_Call{Call: _e.mock.On("SetPromptBroker", broker)}
 }
 
@@ -1617,7 +1617,7 @@ type MockBackend_SetVPNCredentials_Call struct {
 //   - username string
 //   - password string
 //   - save bool
-func (_e *MockBackend_Expecter) SetVPNCredentials(uuid any, username any, password any, save any) *MockBackend_SetVPNCredentials_Call {
+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)}
 }
 
@@ -1664,7 +1664,7 @@ type MockBackend_SetWiFiAutoconnect_Call struct {
 // SetWiFiAutoconnect is a helper method to define mock.On call
 //   - ssid string
 //   - autoconnect bool
-func (_e *MockBackend_Expecter) SetWiFiAutoconnect(ssid any, autoconnect any) *MockBackend_SetWiFiAutoconnect_Call {
+func (_e *MockBackend_Expecter) SetWiFiAutoconnect(ssid interface{}, autoconnect interface{}) *MockBackend_SetWiFiAutoconnect_Call {
 	return &MockBackend_SetWiFiAutoconnect_Call{Call: _e.mock.On("SetWiFiAutoconnect", ssid, autoconnect)}
 }
 
@@ -1710,7 +1710,7 @@ type MockBackend_SetWiFiEnabled_Call struct {
 
 // SetWiFiEnabled is a helper method to define mock.On call
 //   - enabled bool
-func (_e *MockBackend_Expecter) SetWiFiEnabled(enabled any) *MockBackend_SetWiFiEnabled_Call {
+func (_e *MockBackend_Expecter) SetWiFiEnabled(enabled interface{}) *MockBackend_SetWiFiEnabled_Call {
 	return &MockBackend_SetWiFiEnabled_Call{Call: _e.mock.On("SetWiFiEnabled", enabled)}
 }
 
@@ -1756,7 +1756,7 @@ type MockBackend_StartMonitoring_Call struct {
 
 // StartMonitoring is a helper method to define mock.On call
 //   - onStateChange func()
-func (_e *MockBackend_Expecter) StartMonitoring(onStateChange any) *MockBackend_StartMonitoring_Call {
+func (_e *MockBackend_Expecter) StartMonitoring(onStateChange interface{}) *MockBackend_StartMonitoring_Call {
 	return &MockBackend_StartMonitoring_Call{Call: _e.mock.On("StartMonitoring", onStateChange)}
 }
 
@@ -1836,7 +1836,7 @@ type MockBackend_SubmitCredentials_Call struct {
 //   - token string
 //   - secrets map[string]string
 //   - save bool
-func (_e *MockBackend_Expecter) SubmitCredentials(token any, secrets any, save any) *MockBackend_SubmitCredentials_Call {
+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)}
 }
 
@@ -1858,7 +1858,7 @@ func (_c *MockBackend_SubmitCredentials_Call) RunAndReturn(run func(string, map[
 }
 
 // UpdateVPNConfig provides a mock function with given fields: uuid, updates
-func (_m *MockBackend) UpdateVPNConfig(uuid string, updates map[string]any) error {
+func (_m *MockBackend) UpdateVPNConfig(uuid string, updates map[string]interface{}) error {
 	ret := _m.Called(uuid, updates)
 
 	if len(ret) == 0 {
@@ -1866,7 +1866,7 @@ func (_m *MockBackend) UpdateVPNConfig(uuid string, updates map[string]any) erro
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(string, map[string]any) error); ok {
+	if rf, ok := ret.Get(0).(func(string, map[string]interface{}) error); ok {
 		r0 = rf(uuid, updates)
 	} else {
 		r0 = ret.Error(0)
@@ -1882,14 +1882,14 @@ type MockBackend_UpdateVPNConfig_Call struct {
 
 // UpdateVPNConfig is a helper method to define mock.On call
 //   - uuid string
-//   - updates map[string]any
-func (_e *MockBackend_Expecter) UpdateVPNConfig(uuid any, updates any) *MockBackend_UpdateVPNConfig_Call {
+//   - 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]any)) *MockBackend_UpdateVPNConfig_Call {
+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]any))
+		run(args[0].(string), args[1].(map[string]interface{}))
 	})
 	return _c
 }
@@ -1899,7 +1899,7 @@ func (_c *MockBackend_UpdateVPNConfig_Call) Return(_a0 error) *MockBackend_Updat
 	return _c
 }
 
-func (_c *MockBackend_UpdateVPNConfig_Call) RunAndReturn(run func(string, map[string]any) error) *MockBackend_UpdateVPNConfig_Call {
+func (_c *MockBackend_UpdateVPNConfig_Call) RunAndReturn(run func(string, map[string]interface{}) error) *MockBackend_UpdateVPNConfig_Call {
 	_c.Call.Return(run)
 	return _c
 }
diff --git a/core/internal/mocks/version/mock_VersionFetcher.go b/core/internal/mocks/version/mock_VersionFetcher.go
index 19422859..a6fa27c9 100644
--- a/core/internal/mocks/version/mock_VersionFetcher.go
+++ b/core/internal/mocks/version/mock_VersionFetcher.go
@@ -52,7 +52,7 @@ type MockVersionFetcher_GetCurrentVersion_Call struct {
 
 // GetCurrentVersion is a helper method to define mock.On call
 //   - dmsPath string
-func (_e *MockVersionFetcher_Expecter) GetCurrentVersion(dmsPath any) *MockVersionFetcher_GetCurrentVersion_Call {
+func (_e *MockVersionFetcher_Expecter) GetCurrentVersion(dmsPath interface{}) *MockVersionFetcher_GetCurrentVersion_Call {
 	return &MockVersionFetcher_GetCurrentVersion_Call{Call: _e.mock.On("GetCurrentVersion", dmsPath)}
 }
 
@@ -108,7 +108,7 @@ type MockVersionFetcher_GetLatestVersion_Call struct {
 
 // GetLatestVersion is a helper method to define mock.On call
 //   - dmsPath string
-func (_e *MockVersionFetcher_Expecter) GetLatestVersion(dmsPath any) *MockVersionFetcher_GetLatestVersion_Call {
+func (_e *MockVersionFetcher_Expecter) GetLatestVersion(dmsPath interface{}) *MockVersionFetcher_GetLatestVersion_Call {
 	return &MockVersionFetcher_GetLatestVersion_Call{Call: _e.mock.On("GetLatestVersion", dmsPath)}
 }
 
diff --git a/core/internal/server/apppicker/handlers.go b/core/internal/server/apppicker/handlers.go
index e79ce670..1cfa2452 100644
--- a/core/internal/server/apppicker/handlers.go
+++ b/core/internal/server/apppicker/handlers.go
@@ -8,9 +8,9 @@ import (
 )
 
 type Request struct {
-	ID     int                    `json:"id"`
-	Method string                 `json:"method"`
-	Params map[string]interface{} `json:"params"`
+	ID     int            `json:"id"`
+	Method string         `json:"method"`
+	Params map[string]any `json:"params"`
 }
 
 func HandleRequest(conn net.Conn, req Request, manager *Manager) {
@@ -44,7 +44,7 @@ func handleOpen(conn net.Conn, req Request, manager *Manager) {
 		event.MimeType = mimeType
 	}
 
-	if categories, ok := req.Params["categories"].([]interface{}); ok {
+	if categories, ok := req.Params["categories"].([]any); ok {
 		event.Categories = make([]string, 0, len(categories))
 		for _, cat := range categories {
 			if catStr, ok := cat.(string); ok {
diff --git a/core/internal/server/browser/handlers.go b/core/internal/server/browser/handlers.go
index 3962c7ab..a6721c3d 100644
--- a/core/internal/server/browser/handlers.go
+++ b/core/internal/server/browser/handlers.go
@@ -7,9 +7,9 @@ import (
 )
 
 type Request struct {
-	ID     int                    `json:"id"`
-	Method string                 `json:"method"`
-	Params map[string]interface{} `json:"params"`
+	ID     int            `json:"id"`
+	Method string         `json:"method"`
+	Params map[string]any `json:"params"`
 }
 
 func HandleRequest(conn net.Conn, req Request, manager *Manager) {
diff --git a/core/internal/server/cups/handlers_test.go b/core/internal/server/cups/handlers_test.go
index 9fb909dc..0f7fcf4d 100644
--- a/core/internal/server/cups/handlers_test.go
+++ b/core/internal/server/cups/handlers_test.go
@@ -356,7 +356,7 @@ func TestHandleCreatePrinter(t *testing.T) {
 	req := Request{
 		ID:     1,
 		Method: "cups.createPrinter",
-		Params: map[string]interface{}{
+		Params: map[string]any{
 			"name":      "newprinter",
 			"deviceURI": "usb://HP",
 			"ppd":       "generic.ppd",
@@ -377,10 +377,10 @@ func TestHandleCreatePrinter_MissingParams(t *testing.T) {
 	buf := &bytes.Buffer{}
 	conn := &mockConn{Buffer: buf}
 
-	req := Request{ID: 1, Method: "cups.createPrinter", Params: map[string]interface{}{}}
+	req := Request{ID: 1, Method: "cups.createPrinter", Params: map[string]any{}}
 	handleCreatePrinter(conn, req, m)
 
-	var resp models.Response[interface{}]
+	var resp models.Response[any]
 	err := json.NewDecoder(buf).Decode(&resp)
 	assert.NoError(t, err)
 	assert.Nil(t, resp.Result)
@@ -399,7 +399,7 @@ func TestHandleDeletePrinter(t *testing.T) {
 	req := Request{
 		ID:     1,
 		Method: "cups.deletePrinter",
-		Params: map[string]interface{}{"printerName": "printer1"},
+		Params: map[string]any{"printerName": "printer1"},
 	}
 	handleDeletePrinter(conn, req, m)
 
@@ -422,7 +422,7 @@ func TestHandleAcceptJobs(t *testing.T) {
 	req := Request{
 		ID:     1,
 		Method: "cups.acceptJobs",
-		Params: map[string]interface{}{"printerName": "printer1"},
+		Params: map[string]any{"printerName": "printer1"},
 	}
 	handleAcceptJobs(conn, req, m)
 
@@ -445,7 +445,7 @@ func TestHandleRejectJobs(t *testing.T) {
 	req := Request{
 		ID:     1,
 		Method: "cups.rejectJobs",
-		Params: map[string]interface{}{"printerName": "printer1"},
+		Params: map[string]any{"printerName": "printer1"},
 	}
 	handleRejectJobs(conn, req, m)
 
@@ -468,7 +468,7 @@ func TestHandleSetPrinterShared(t *testing.T) {
 	req := Request{
 		ID:     1,
 		Method: "cups.setPrinterShared",
-		Params: map[string]interface{}{"printerName": "printer1", "shared": true},
+		Params: map[string]any{"printerName": "printer1", "shared": true},
 	}
 	handleSetPrinterShared(conn, req, m)
 
@@ -491,7 +491,7 @@ func TestHandleSetPrinterLocation(t *testing.T) {
 	req := Request{
 		ID:     1,
 		Method: "cups.setPrinterLocation",
-		Params: map[string]interface{}{"printerName": "printer1", "location": "Office"},
+		Params: map[string]any{"printerName": "printer1", "location": "Office"},
 	}
 	handleSetPrinterLocation(conn, req, m)
 
@@ -514,7 +514,7 @@ func TestHandleSetPrinterInfo(t *testing.T) {
 	req := Request{
 		ID:     1,
 		Method: "cups.setPrinterInfo",
-		Params: map[string]interface{}{"printerName": "printer1", "info": "Main Printer"},
+		Params: map[string]any{"printerName": "printer1", "info": "Main Printer"},
 	}
 	handleSetPrinterInfo(conn, req, m)
 
@@ -537,7 +537,7 @@ func TestHandleMoveJob(t *testing.T) {
 	req := Request{
 		ID:     1,
 		Method: "cups.moveJob",
-		Params: map[string]interface{}{"jobID": float64(1), "destPrinter": "printer2"},
+		Params: map[string]any{"jobID": float64(1), "destPrinter": "printer2"},
 	}
 	handleMoveJob(conn, req, m)
 
@@ -560,7 +560,7 @@ func TestHandlePrintTestPage(t *testing.T) {
 	req := Request{
 		ID:     1,
 		Method: "cups.printTestPage",
-		Params: map[string]interface{}{"printerName": "printer1"},
+		Params: map[string]any{"printerName": "printer1"},
 	}
 	handlePrintTestPage(conn, req, m)
 
@@ -584,7 +584,7 @@ func TestHandleAddPrinterToClass(t *testing.T) {
 	req := Request{
 		ID:     1,
 		Method: "cups.addPrinterToClass",
-		Params: map[string]interface{}{"className": "office", "printerName": "printer1"},
+		Params: map[string]any{"className": "office", "printerName": "printer1"},
 	}
 	handleAddPrinterToClass(conn, req, m)
 
@@ -607,7 +607,7 @@ func TestHandleRemovePrinterFromClass(t *testing.T) {
 	req := Request{
 		ID:     1,
 		Method: "cups.removePrinterFromClass",
-		Params: map[string]interface{}{"className": "office", "printerName": "printer1"},
+		Params: map[string]any{"className": "office", "printerName": "printer1"},
 	}
 	handleRemovePrinterFromClass(conn, req, m)
 
@@ -630,7 +630,7 @@ func TestHandleDeleteClass(t *testing.T) {
 	req := Request{
 		ID:     1,
 		Method: "cups.deleteClass",
-		Params: map[string]interface{}{"className": "office"},
+		Params: map[string]any{"className": "office"},
 	}
 	handleDeleteClass(conn, req, m)
 
@@ -653,7 +653,7 @@ func TestHandleRestartJob(t *testing.T) {
 	req := Request{
 		ID:     1,
 		Method: "cups.restartJob",
-		Params: map[string]interface{}{"jobID": float64(1)},
+		Params: map[string]any{"jobID": float64(1)},
 	}
 	handleRestartJob(conn, req, m)
 
@@ -676,7 +676,7 @@ func TestHandleHoldJob(t *testing.T) {
 	req := Request{
 		ID:     1,
 		Method: "cups.holdJob",
-		Params: map[string]interface{}{"jobID": float64(1)},
+		Params: map[string]any{"jobID": float64(1)},
 	}
 	handleHoldJob(conn, req, m)
 
@@ -699,7 +699,7 @@ func TestHandleHoldJob_WithHoldUntil(t *testing.T) {
 	req := Request{
 		ID:     1,
 		Method: "cups.holdJob",
-		Params: map[string]interface{}{"jobID": float64(1), "holdUntil": "no-hold"},
+		Params: map[string]any{"jobID": float64(1), "holdUntil": "no-hold"},
 	}
 	handleHoldJob(conn, req, m)
 
diff --git a/core/internal/server/cups/pkhelper.go b/core/internal/server/cups/pkhelper.go
index f4b713f0..81dd4587 100644
--- a/core/internal/server/cups/pkhelper.go
+++ b/core/internal/server/cups/pkhelper.go
@@ -167,7 +167,7 @@ func (p *DBusPkHelper) JobSetHoldUntil(jobID int, holdUntil string) error {
 	return p.callSimple("JobSetHoldUntil", int32(jobID), holdUntil)
 }
 
-func (p *DBusPkHelper) callSimple(method string, args ...interface{}) error {
+func (p *DBusPkHelper) callSimple(method string, args ...any) error {
 	var errStr string
 
 	call := p.obj.Call(pkHelperInterface+"."+method, 0, args...)
diff --git a/core/internal/server/server.go b/core/internal/server/server.go
index eae6fa3d..f4e6c460 100644
--- a/core/internal/server/server.go
+++ b/core/internal/server/server.go
@@ -1346,7 +1346,7 @@ func Start(printDocs bool) error {
 	if wlContext != nil {
 		go func() {
 			err := <-wlContext.FatalError()
-			fatalErrChan <- fmt.Errorf("Wayland context fatal error: %w", err)
+			fatalErrChan <- fmt.Errorf("wayland context fatal error: %w", err)
 		}()
 	}
 
diff --git a/core/internal/server/wayland/manager.go b/core/internal/server/wayland/manager.go
index aab82397..9b31ca95 100644
--- a/core/internal/server/wayland/manager.go
+++ b/core/internal/server/wayland/manager.go
@@ -78,7 +78,7 @@ func NewManager(display *wlclient.Display, config Config) (*Manager, error) {
 			log.Info("Gamma control enabled at startup, initializing controls")
 			gammaMgr := m.gammaControl.(*wlr_gamma_control.ZwlrGammaControlManagerV1)
 			if err := func() error {
-				var outputs []*wlclient.Output = m.availableOutputs
+				outputs := m.availableOutputs
 				return m.setupOutputControls(outputs, gammaMgr)
 			}(); err != nil {
 				log.Errorf("Failed to initialize gamma controls: %v", err)
@@ -573,6 +573,7 @@ func (m *Manager) transitionWorker() {
 
 			log.Debugf("Starting smooth transition: %dK -> %dK over %v", currentTemp, targetTemp, dur)
 
+		stepLoop:
 			for i := 0; i <= steps; i++ {
 				select {
 				case newTarget := <-m.transitionChan:
@@ -580,7 +581,7 @@ func (m *Manager) transitionWorker() {
 					m.targetTemp = newTarget
 					m.transitionMutex.Unlock()
 					log.Debugf("Transition %dK -> %dK aborted (newer transition started)", currentTemp, targetTemp)
-					break
+					break stepLoop
 				default:
 				}
 
@@ -1214,7 +1215,7 @@ func (m *Manager) SetEnabled(enabled bool) {
 				log.Info("Creating gamma controls")
 				gammaMgr := m.gammaControl.(*wlr_gamma_control.ZwlrGammaControlManagerV1)
 				if err := func() error {
-					var outputs []*wlclient.Output = m.availableOutputs
+					outputs := m.availableOutputs
 					return m.setupOutputControls(outputs, gammaMgr)
 				}(); err != nil {
 					log.Errorf("Failed to create gamma controls: %v", err)
diff --git a/core/pkg/ipp/adapter-http.go b/core/pkg/ipp/adapter-http.go
index 8b303eca..56ababb8 100644
--- a/core/pkg/ipp/adapter-http.go
+++ b/core/pkg/ipp/adapter-http.go
@@ -122,7 +122,7 @@ func (h *HttpAdapter) GetHttpUri(namespace string, object any) string {
 }
 
 func (h *HttpAdapter) TestConnection() error {
-	conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", h.host, h.port))
+	conn, err := net.Dial("tcp", net.JoinHostPort(h.host, fmt.Sprintf("%d", h.port)))
 	if err != nil {
 		return err
 	}