diff --git a/ElementX/Sources/Application/AppCoordinatorStateMachine.swift b/ElementX/Sources/Application/AppCoordinatorStateMachine.swift
index 47052ef27..9de14967c 100644
--- a/ElementX/Sources/Application/AppCoordinatorStateMachine.swift
+++ b/ElementX/Sources/Application/AppCoordinatorStateMachine.swift
@@ -104,8 +104,8 @@ class AppCoordinatorStateMachine {
 
         // Transitions with associated values need to be handled through `addRouteMapping`
         stateMachine.addRouteMapping { event, fromState, _ in
-            switch (event, fromState) {
-            case (.signOut(let isSoft, let disableAppLock), _):
+            switch (fromState, event) {
+            case (_, .signOut(let isSoft, let disableAppLock)):
                 return .signingOut(isSoft: isSoft, disableAppLock: disableAppLock)
             default:
                 return nil
diff --git a/ElementX/Sources/FlowCoordinators/AppLockSetupFlowCoordinator.swift b/ElementX/Sources/FlowCoordinators/AppLockSetupFlowCoordinator.swift
index 70f517a58..d43449b20 100644
--- a/ElementX/Sources/FlowCoordinators/AppLockSetupFlowCoordinator.swift
+++ b/ElementX/Sources/FlowCoordinators/AppLockSetupFlowCoordinator.swift
@@ -111,17 +111,17 @@ class AppLockSetupFlowCoordinator: FlowCoordinatorProtocol {
         stateMachine.addRouteMapping { [weak self] event, fromState, _ in
             guard let self else { return nil }
             
-            switch (event, fromState) {
-            case (.start, .initial):
+            switch (fromState, event) {
+            case (.initial, .start):
                 if presentingFlow == .onboarding { return .createPIN(replacingExitingPIN: false) }
                 return appLockService.isEnabled ? .unlock : .createPIN(replacingExitingPIN: false)
-            case (.pinEntered, .unlock):
+            case (.unlock, .pinEntered):
                 return .settings
-            case (.cancel, .unlock):
+            case (.unlock, .cancel):
                 return .complete
-            case (.forceLogout, .unlock):
+            case (.unlock, .forceLogout):
                 return .loggingOut
-            case (.pinEntered, .createPIN(let replacingExitingPIN)):
+            case (.createPIN(let replacingExitingPIN), .pinEntered):
                 if presentingFlow == .onboarding {
                     return appLockService.biometryType != .none ? .biometricsPrompt : .complete
                 } else if !replacingExitingPIN {
@@ -129,13 +129,13 @@ class AppLockSetupFlowCoordinator: FlowCoordinatorProtocol {
                 } else {
                     return .settings
                 }
-            case (.cancel, .createPIN(let replacingExitingPIN)):
+            case (.createPIN(let replacingExitingPIN), .cancel):
                 return replacingExitingPIN ? .settings : .complete
-            case (.biometricsSet, .biometricsPrompt):
+            case (.biometricsPrompt, .biometricsSet):
                 return presentingFlow == .settings ? .settings : .complete
-            case (.changePIN, .settings):
+            case (.settings, .changePIN):
                 return .createPIN(replacingExitingPIN: true)
-            case (.appLockDisabled, .settings):
+            case (.settings, .appLockDisabled):
                 return .complete
             default:
                 return nil
diff --git a/ElementX/Sources/FlowCoordinators/RoomFlowCoordinator.swift b/ElementX/Sources/FlowCoordinators/RoomFlowCoordinator.swift
index 4f1458a95..a4d7d5148 100644
--- a/ElementX/Sources/FlowCoordinators/RoomFlowCoordinator.swift
+++ b/ElementX/Sources/FlowCoordinators/RoomFlowCoordinator.swift
@@ -124,92 +124,92 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
     // swiftlint:disable:next function_body_length
     private func setupStateMachine() {
         stateMachine.addRouteMapping { event, fromState, _ in
-            switch (event, fromState) {
-            case (.presentRoom(let roomID), _):
+            switch (fromState, event) {
+            case (_, .presentRoom(let roomID)):
                 return .room(roomID: roomID)
-            case (.dismissRoom, .room):
+            case (.room, .dismissRoom):
                 return .initial
                 
-            case (.presentRoomDetails(let roomID), .initial):
+            case (.initial, .presentRoomDetails(let roomID)):
                 return .roomDetails(roomID: roomID, isRoot: true)
-            case (.presentRoomDetails(let roomID), .room(let currentRoomID)):
+            case (.room(let currentRoomID), .presentRoomDetails(let roomID)):
                 return .roomDetails(roomID: roomID, isRoot: roomID != currentRoomID)
-            case (.presentRoomDetails(let roomID), .roomDetails(let currentRoomID, _)):
+            case (.roomDetails(let currentRoomID, _), .presentRoomDetails(let roomID)):
                 return .roomDetails(roomID: roomID, isRoot: roomID != currentRoomID)
-            case (.dismissRoomDetails, .roomDetails(let roomID, _)):
+            case (.roomDetails(let roomID, _), .dismissRoomDetails):
                 return .room(roomID: roomID)
-            case (.dismissRoom, .roomDetails):
+            case (.roomDetails, .dismissRoom):
                 return .initial
                 
-            case (.presentRoomDetailsEditScreen, .roomDetails(let roomID, _)):
+            case (.roomDetails(let roomID, _), .presentRoomDetailsEditScreen):
                 return .roomDetailsEditScreen(roomID: roomID)
-            case (.dismissRoomDetailsEditScreen, .roomDetailsEditScreen(let roomID)):
+            case (.roomDetailsEditScreen(let roomID), .dismissRoomDetailsEditScreen):
                 return .roomDetails(roomID: roomID, isRoot: false)
                 
-            case (.presentNotificationSettingsScreen, .roomDetails(let roomID, _)):
+            case (.roomDetails(let roomID, _), .presentNotificationSettingsScreen):
                 return .notificationSettings(roomID: roomID)
-            case (.dismissNotificationSettingsScreen, .notificationSettings(let roomID)):
+            case (.notificationSettings(let roomID), .dismissNotificationSettingsScreen):
                 return .roomDetails(roomID: roomID, isRoot: false)
                 
-            case (.presentGlobalNotificationSettingsScreen, .notificationSettings(let roomID)):
+            case (.notificationSettings(let roomID), .presentGlobalNotificationSettingsScreen):
                 return .globalNotificationSettings(roomID: roomID)
-            case (.dismissGlobalNotificationSettingsScreen, .globalNotificationSettings(let roomID)):
+            case (.globalNotificationSettings(let roomID), .dismissGlobalNotificationSettingsScreen):
                 return .notificationSettings(roomID: roomID)
                 
-            case (.presentRoomMembersList, .roomDetails(let roomID, _)):
+            case (.roomDetails(let roomID, _), .presentRoomMembersList):
                 return .roomMembersList(roomID: roomID)
-            case (.dismissRoomMembersList, .roomMembersList(let roomID)):
+            case (.roomMembersList(let roomID), .dismissRoomMembersList):
                 return .roomDetails(roomID: roomID, isRoot: false)
 
-            case (.presentRoomMemberDetails(let member), .room(let roomID)):
+            case (.room(let roomID), .presentRoomMemberDetails(let member)):
                 return .roomMemberDetails(roomID: roomID, member: member, fromRoomMembersList: false)
-            case (.presentRoomMemberDetails(let member), .roomMembersList(let roomID)):
+            case (.roomMembersList(let roomID), .presentRoomMemberDetails(let member)):
                 return .roomMemberDetails(roomID: roomID, member: member, fromRoomMembersList: true)
-            case (.dismissRoomMemberDetails, .roomMemberDetails(let roomID, _, let fromRoomMembersList)):
+            case (.roomMemberDetails(let roomID, _, let fromRoomMembersList), .dismissRoomMemberDetails):
                 return fromRoomMembersList ? .roomMembersList(roomID: roomID) : .room(roomID: roomID)
                 
-            case (.presentInviteUsersScreen, .roomDetails(let roomID, _)):
+            case (.roomDetails(let roomID, _), .presentInviteUsersScreen):
                 return .inviteUsersScreen(roomID: roomID, fromRoomMembersList: false)
-            case (.presentInviteUsersScreen, .roomMembersList(let roomID)):
+            case (.roomMembersList(let roomID), .presentInviteUsersScreen):
                 return .inviteUsersScreen(roomID: roomID, fromRoomMembersList: true)
-            case (.dismissInviteUsersScreen, .inviteUsersScreen(let roomID, let fromRoomMembersList)):
+            case (.inviteUsersScreen(let roomID, let fromRoomMembersList), .dismissInviteUsersScreen):
                 return fromRoomMembersList ? .roomMembersList(roomID: roomID) : .roomDetails(roomID: roomID, isRoot: false)
                 
-            case (.presentReportContent(let itemID, let senderID), .room(let roomID)):
+            case (.room(let roomID), .presentReportContent(let itemID, let senderID)):
                 return .reportContent(roomID: roomID, itemID: itemID, senderID: senderID)
-            case (.dismissReportContent, .reportContent(let roomID, _, _)):
+            case (.reportContent(let roomID, _, _), .dismissReportContent):
                 return .room(roomID: roomID)
                 
-            case (.presentMediaUploadPicker(let source), .room(let roomID)):
+            case (.room(let roomID), .presentMediaUploadPicker(let source)):
                 return .mediaUploadPicker(roomID: roomID, source: source)
-            case (.dismissMediaUploadPicker, .mediaUploadPicker(let roomID, _)):
+            case (.mediaUploadPicker(let roomID, _), .dismissMediaUploadPicker):
                 return .room(roomID: roomID)
                 
-            case (.presentMediaUploadPreview(let fileURL), .mediaUploadPicker(let roomID, _)):
+            case (.mediaUploadPicker(let roomID, _), .presentMediaUploadPreview(let fileURL)):
                 return .mediaUploadPreview(roomID: roomID, fileURL: fileURL)
-            case (.presentMediaUploadPreview(let fileURL), .room(let roomID)):
+            case (.room(let roomID), .presentMediaUploadPreview(let fileURL)):
                 return .mediaUploadPreview(roomID: roomID, fileURL: fileURL)
-            case (.dismissMediaUploadPreview, .mediaUploadPreview(let roomID, _)):
+            case (.mediaUploadPreview(let roomID, _), .dismissMediaUploadPreview):
                 return .room(roomID: roomID)
                 
-            case (.presentEmojiPicker(let itemID, let selectedEmoji), .room(let roomID)):
+            case (.room(let roomID), .presentEmojiPicker(let itemID, let selectedEmoji)):
                 return .emojiPicker(roomID: roomID, itemID: itemID, selectedEmojis: selectedEmoji)
-            case (.dismissEmojiPicker, .emojiPicker(let roomID, _, _)):
+            case (.emojiPicker(let roomID, _, _), .dismissEmojiPicker):
                 return .room(roomID: roomID)
 
-            case (.presentMessageForwarding(let itemID), .room(let roomID)):
+            case (.room(let roomID), .presentMessageForwarding(let itemID)):
                 return .messageForwarding(roomID: roomID, itemID: itemID)
-            case (.dismissMessageForwarding, .messageForwarding(let roomID, _)):
+            case (.messageForwarding(let roomID, _), .dismissMessageForwarding):
                 return .room(roomID: roomID)
 
-            case (.presentMapNavigator, .room(let roomID)):
+            case (.room(let roomID), .presentMapNavigator):
                 return .mapNavigator(roomID: roomID)
-            case (.dismissMapNavigator, .mapNavigator(let roomID)):
+            case (.mapNavigator(let roomID), .dismissMapNavigator):
                 return .room(roomID: roomID)
 
-            case (.presentPollForm, .room(let roomID)):
+            case (.room(let roomID), .presentPollForm):
                 return .pollForm(roomID: roomID)
-            case (.dismissPollForm, .pollForm(let roomID)):
+            case (.pollForm(let roomID), .dismissPollForm):
                 return .room(roomID: roomID)
 
             default:
diff --git a/ElementX/Sources/FlowCoordinators/UserSessionFlowCoordinatorStateMachine.swift b/ElementX/Sources/FlowCoordinators/UserSessionFlowCoordinatorStateMachine.swift
index 02b088515..3defa519a 100644
--- a/ElementX/Sources/FlowCoordinators/UserSessionFlowCoordinatorStateMachine.swift
+++ b/ElementX/Sources/FlowCoordinators/UserSessionFlowCoordinatorStateMachine.swift
@@ -130,50 +130,50 @@ class UserSessionFlowCoordinatorStateMachine {
         stateMachine.addRoutes(event: .dismissedWelcomeScreen, transitions: [.welcomeScreen => .roomList(selectedRoomID: nil)])
 
         stateMachine.addRouteMapping { event, fromState, _ in
-            switch (event, fromState) {
-            case (.selectRoom(let roomID), .roomList):
+            switch (fromState, event) {
+            case (.roomList, .selectRoom(let roomID)):
                 return .roomList(selectedRoomID: roomID)
-            case (.selectRoom(let roomID), .invitesScreen):
+            case (.invitesScreen, .selectRoom(let roomID)):
                 return .invitesScreen(selectedRoomID: roomID)
-            case (.deselectRoom, .roomList):
+            case (.roomList, .deselectRoom):
                 return .roomList(selectedRoomID: nil)
-            case (.deselectRoom, .invitesScreen):
+            case (.invitesScreen, .deselectRoom):
                 return .invitesScreen(selectedRoomID: nil)
 
-            case (.showSettingsScreen, .roomList(let selectedRoomID)):
+            case (.roomList(let selectedRoomID), .showSettingsScreen):
                 return .settingsScreen(selectedRoomID: selectedRoomID)
-            case (.dismissedSettingsScreen, .settingsScreen(let selectedRoomID)):
+            case (.settingsScreen(let selectedRoomID), .dismissedSettingsScreen):
                 return .roomList(selectedRoomID: selectedRoomID)
                 
-            case (.feedbackScreen, .roomList(let selectedRoomID)):
+            case (.roomList(let selectedRoomID), .feedbackScreen):
                 return .feedbackScreen(selectedRoomID: selectedRoomID)
-            case (.dismissedFeedbackScreen, .feedbackScreen(let selectedRoomID)):
+            case (.feedbackScreen(let selectedRoomID), .dismissedFeedbackScreen):
                 return .roomList(selectedRoomID: selectedRoomID)
                 
-            case (.showSessionVerificationScreen, .roomList(let selectedRoomID)):
+            case (.roomList(let selectedRoomID), .showSessionVerificationScreen):
                 return .sessionVerificationScreen(selectedRoomID: selectedRoomID)
-            case (.dismissedSessionVerificationScreen, .sessionVerificationScreen(let selectedRoomID)):
+            case (.sessionVerificationScreen(let selectedRoomID), .dismissedSessionVerificationScreen):
                 return .roomList(selectedRoomID: selectedRoomID)
                 
-            case (.showStartChatScreen, .roomList(let selectedRoomID)):
+            case (.roomList(let selectedRoomID), .showStartChatScreen):
                 return .startChatScreen(selectedRoomID: selectedRoomID)
-            case (.dismissedStartChatScreen, .startChatScreen(let selectedRoomID)):
+            case (.startChatScreen(let selectedRoomID), .dismissedStartChatScreen):
                 return .roomList(selectedRoomID: selectedRoomID)
             
-            case (.showInvitesScreen, .roomList(let selectedRoomID)):
+            case (.roomList(let selectedRoomID), .showInvitesScreen):
                 return .invitesScreen(selectedRoomID: selectedRoomID)
-            case (.showInvitesScreen, .invitesScreen(let selectedRoomID)):
+            case (.invitesScreen(let selectedRoomID), .showInvitesScreen):
                 return .invitesScreen(selectedRoomID: selectedRoomID)
 
-            case (.dismissedInvitesScreen, .invitesScreen(let selectedRoomID)):
+            case (.invitesScreen(let selectedRoomID), .dismissedInvitesScreen):
                 return .roomList(selectedRoomID: selectedRoomID)
 
-            case (.presentWelcomeScreen, .roomList):
+            case (.roomList, .presentWelcomeScreen):
                 return .welcomeScreen
                 
-            case (.showLogoutConfirmationScreen, .roomList(let selectedRoomID)):
+            case (.roomList(let selectedRoomID), .showLogoutConfirmationScreen):
                 return .logoutConfirmationScreen(selectedRoomID: selectedRoomID)
-            case (.dismissedLogoutConfirmationScreen, .logoutConfirmationScreen(let selectedRoomID)):
+            case (.logoutConfirmationScreen(let selectedRoomID), .dismissedLogoutConfirmationScreen):
                 return .roomList(selectedRoomID: selectedRoomID)
                 
             default:
diff --git a/ElementX/Sources/Screens/SessionVerificationScreen/SessionVerificationScreenStateMachine.swift b/ElementX/Sources/Screens/SessionVerificationScreen/SessionVerificationScreenStateMachine.swift
index 94d5314fe..ed8fdf832 100644
--- a/ElementX/Sources/Screens/SessionVerificationScreen/SessionVerificationScreenStateMachine.swift
+++ b/ElementX/Sources/Screens/SessionVerificationScreen/SessionVerificationScreenStateMachine.swift
@@ -92,28 +92,28 @@ class SessionVerificationScreenStateMachine {
         
         // Transitions with associated values need to be handled through `addRouteMapping`
         stateMachine.addRouteMapping { event, fromState, _ in
-            switch (event, fromState) {
-            case (.didStartSasVerification, _):
+            switch (fromState, event) {
+            case (_, .didStartSasVerification):
                 return .sasVerificationStarted
                 
-            case (.didReceiveChallenge(let emojis), .sasVerificationStarted):
+            case (.sasVerificationStarted, .didReceiveChallenge(let emojis)):
                 return .showingChallenge(emojis: emojis)
-            case (.acceptChallenge, .showingChallenge(let emojis)):
+            case (.showingChallenge(let emojis), .acceptChallenge):
                 return .acceptingChallenge(emojis: emojis)
-            case (.didFail, .acceptingChallenge(let emojis)):
+            case (.acceptingChallenge(let emojis), .didFail):
                 return .showingChallenge(emojis: emojis)
                 
-            case (.didAcceptChallenge, .acceptingChallenge):
+            case (.acceptingChallenge, .didAcceptChallenge):
                 return .verified
                 
-            case (.declineChallenge, .showingChallenge(let emojis)):
+            case (.showingChallenge(let emojis), .declineChallenge):
                 return .decliningChallenge(emojis: emojis)
-            case (.didFail, .decliningChallenge(let emojis)):
+            case (.decliningChallenge(let emojis), .didFail):
                 return .showingChallenge(emojis: emojis)
                 
-            case (.cancel, _):
+            case (_, .cancel):
                 return .cancelling
-            case (.didCancel, _):
+            case (_, .didCancel):
                 return .cancelled
                 
             default: