Fixes #2842, fixes #2841 - Adopt new message sending queue API

- automatically retry failed requests as soon as the network is availble again - remove manual retry options
2026-11-03 06:55:59 +00:00 · 2024-05-28 10:17:13 +03:00
parent 53fc5df55b
commit 6c1647b851
28 changed files with 827 additions and 606 deletions
@@ -3496,6 +3496,45 @@ class ClientProxyMock: ClientProxyProtocol {
            return resolveRoomAliasReturnValue
        }
    }
+    //MARK: - setSendingQueueEnabled
+
+    var setSendingQueueEnabledUnderlyingCallsCount = 0
+    var setSendingQueueEnabledCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return setSendingQueueEnabledUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = setSendingQueueEnabledUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                setSendingQueueEnabledUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    setSendingQueueEnabledUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    var setSendingQueueEnabledCalled: Bool {
+        return setSendingQueueEnabledCallsCount > 0
+    }
+    var setSendingQueueEnabledReceivedEnabled: Bool?
+    var setSendingQueueEnabledReceivedInvocations: [Bool] = []
+    var setSendingQueueEnabledClosure: ((Bool) -> Void)?
+
+    func setSendingQueueEnabled(_ enabled: Bool) {
+        setSendingQueueEnabledCallsCount += 1
+        setSendingQueueEnabledReceivedEnabled = enabled
+        setSendingQueueEnabledReceivedInvocations.append(enabled)
+        setSendingQueueEnabledClosure?(enabled)
+    }
    //MARK: - ignoreUser

    var ignoreUserUnderlyingCallsCount = 0
@@ -11057,11 +11096,6 @@ class SessionVerificationControllerProxyMock: SessionVerificationControllerProxy
    }
 }
 class TimelineProxyMock: TimelineProxyProtocol {
-    var actions: AnyPublisher<TimelineProxyAction, Never> {
-        get { return underlyingActions }
-        set(value) { underlyingActions = value }
-    }
-    var underlyingActions: AnyPublisher<TimelineProxyAction, Never>!
    var isLive: Bool {
        get { return underlyingIsLive }
        set(value) { underlyingIsLive = value }
@@ -11108,113 +11142,6 @@ class TimelineProxyMock: TimelineProxyProtocol {
        subscribeForUpdatesCallsCount += 1
        await subscribeForUpdatesClosure?()
    }
-    //MARK: - cancelSend
-
-    var cancelSendTransactionIDUnderlyingCallsCount = 0
-    var cancelSendTransactionIDCallsCount: Int {
-        get {
-            if Thread.isMainThread {
-                return cancelSendTransactionIDUnderlyingCallsCount
-            } else {
-                var returnValue: Int? = nil
-                DispatchQueue.main.sync {
-                    returnValue = cancelSendTransactionIDUnderlyingCallsCount
-                }
-
-                return returnValue!
-            }
-        }
-        set {
-            if Thread.isMainThread {
-                cancelSendTransactionIDUnderlyingCallsCount = newValue
-            } else {
-                DispatchQueue.main.sync {
-                    cancelSendTransactionIDUnderlyingCallsCount = newValue
-                }
-            }
-        }
-    }
-    var cancelSendTransactionIDCalled: Bool {
-        return cancelSendTransactionIDCallsCount > 0
-    }
-    var cancelSendTransactionIDReceivedTransactionID: String?
-    var cancelSendTransactionIDReceivedInvocations: [String] = []
-    var cancelSendTransactionIDClosure: ((String) async -> Void)?
-
-    func cancelSend(transactionID: String) async {
-        cancelSendTransactionIDCallsCount += 1
-        cancelSendTransactionIDReceivedTransactionID = transactionID
-        cancelSendTransactionIDReceivedInvocations.append(transactionID)
-        await cancelSendTransactionIDClosure?(transactionID)
-    }
-    //MARK: - editMessage
-
-    var editMessageHtmlOriginalIntentionalMentionsUnderlyingCallsCount = 0
-    var editMessageHtmlOriginalIntentionalMentionsCallsCount: Int {
-        get {
-            if Thread.isMainThread {
-                return editMessageHtmlOriginalIntentionalMentionsUnderlyingCallsCount
-            } else {
-                var returnValue: Int? = nil
-                DispatchQueue.main.sync {
-                    returnValue = editMessageHtmlOriginalIntentionalMentionsUnderlyingCallsCount
-                }
-
-                return returnValue!
-            }
-        }
-        set {
-            if Thread.isMainThread {
-                editMessageHtmlOriginalIntentionalMentionsUnderlyingCallsCount = newValue
-            } else {
-                DispatchQueue.main.sync {
-                    editMessageHtmlOriginalIntentionalMentionsUnderlyingCallsCount = newValue
-                }
-            }
-        }
-    }
-    var editMessageHtmlOriginalIntentionalMentionsCalled: Bool {
-        return editMessageHtmlOriginalIntentionalMentionsCallsCount > 0
-    }
-    var editMessageHtmlOriginalIntentionalMentionsReceivedArguments: (message: String, html: String?, eventID: String, intentionalMentions: IntentionalMentions)?
-    var editMessageHtmlOriginalIntentionalMentionsReceivedInvocations: [(message: String, html: String?, eventID: String, intentionalMentions: IntentionalMentions)] = []
-
-    var editMessageHtmlOriginalIntentionalMentionsUnderlyingReturnValue: Result<Void, TimelineProxyError>!
-    var editMessageHtmlOriginalIntentionalMentionsReturnValue: Result<Void, TimelineProxyError>! {
-        get {
-            if Thread.isMainThread {
-                return editMessageHtmlOriginalIntentionalMentionsUnderlyingReturnValue
-            } else {
-                var returnValue: Result<Void, TimelineProxyError>? = nil
-                DispatchQueue.main.sync {
-                    returnValue = editMessageHtmlOriginalIntentionalMentionsUnderlyingReturnValue
-                }
-
-                return returnValue!
-            }
-        }
-        set {
-            if Thread.isMainThread {
-                editMessageHtmlOriginalIntentionalMentionsUnderlyingReturnValue = newValue
-            } else {
-                DispatchQueue.main.sync {
-                    editMessageHtmlOriginalIntentionalMentionsUnderlyingReturnValue = newValue
-                }
-            }
-        }
-    }
-    var editMessageHtmlOriginalIntentionalMentionsClosure: ((String, String?, String, IntentionalMentions) async -> Result<Void, TimelineProxyError>)?
-
-    func editMessage(_ message: String, html: String?, original eventID: String, intentionalMentions: IntentionalMentions) async -> Result<Void, TimelineProxyError> {
-        editMessageHtmlOriginalIntentionalMentionsCallsCount += 1
-        editMessageHtmlOriginalIntentionalMentionsReceivedArguments = (message: message, html: html, eventID: eventID, intentionalMentions: intentionalMentions)
-        editMessageHtmlOriginalIntentionalMentionsReceivedInvocations.append((message: message, html: html, eventID: eventID, intentionalMentions: intentionalMentions))
-        if let editMessageHtmlOriginalIntentionalMentionsClosure = editMessageHtmlOriginalIntentionalMentionsClosure {
-            return await editMessageHtmlOriginalIntentionalMentionsClosure(message, html, eventID, intentionalMentions)
-        } else {
-            return editMessageHtmlOriginalIntentionalMentionsReturnValue
-        }
-    }
    //MARK: - fetchDetails

    var fetchDetailsForUnderlyingCallsCount = 0
@@ -11283,8 +11210,8 @@ class TimelineProxyMock: TimelineProxyProtocol {
    var messageEventContentForCalled: Bool {
        return messageEventContentForCallsCount > 0
    }
-    var messageEventContentForReceivedEventID: String?
-    var messageEventContentForReceivedInvocations: [String] = []
+    var messageEventContentForReceivedTimelineItemID: TimelineItemIdentifier?
+    var messageEventContentForReceivedInvocations: [TimelineItemIdentifier] = []

    var messageEventContentForUnderlyingReturnValue: RoomMessageEventContentWithoutRelation?
    var messageEventContentForReturnValue: RoomMessageEventContentWithoutRelation? {
@@ -11310,14 +11237,14 @@ class TimelineProxyMock: TimelineProxyProtocol {
            }
        }
    }
-    var messageEventContentForClosure: ((String) async -> RoomMessageEventContentWithoutRelation?)?
+    var messageEventContentForClosure: ((TimelineItemIdentifier) async -> RoomMessageEventContentWithoutRelation?)?

-    func messageEventContent(for eventID: String) async -> RoomMessageEventContentWithoutRelation? {
+    func messageEventContent(for timelineItemID: TimelineItemIdentifier) async -> RoomMessageEventContentWithoutRelation? {
        messageEventContentForCallsCount += 1
-        messageEventContentForReceivedEventID = eventID
-        messageEventContentForReceivedInvocations.append(eventID)
+        messageEventContentForReceivedTimelineItemID = timelineItemID
+        messageEventContentForReceivedInvocations.append(timelineItemID)
        if let messageEventContentForClosure = messageEventContentForClosure {
-            return await messageEventContentForClosure(eventID)
+            return await messageEventContentForClosure(timelineItemID)
        } else {
            return messageEventContentForReturnValue
        }
@@ -11361,45 +11288,6 @@ class TimelineProxyMock: TimelineProxyProtocol {
        retryDecryptionForReceivedInvocations.append(sessionID)
        await retryDecryptionForClosure?(sessionID)
    }
-    //MARK: - retrySend
-
-    var retrySendTransactionIDUnderlyingCallsCount = 0
-    var retrySendTransactionIDCallsCount: Int {
-        get {
-            if Thread.isMainThread {
-                return retrySendTransactionIDUnderlyingCallsCount
-            } else {
-                var returnValue: Int? = nil
-                DispatchQueue.main.sync {
-                    returnValue = retrySendTransactionIDUnderlyingCallsCount
-                }
-
-                return returnValue!
-            }
-        }
-        set {
-            if Thread.isMainThread {
-                retrySendTransactionIDUnderlyingCallsCount = newValue
-            } else {
-                DispatchQueue.main.sync {
-                    retrySendTransactionIDUnderlyingCallsCount = newValue
-                }
-            }
-        }
-    }
-    var retrySendTransactionIDCalled: Bool {
-        return retrySendTransactionIDCallsCount > 0
-    }
-    var retrySendTransactionIDReceivedTransactionID: String?
-    var retrySendTransactionIDReceivedInvocations: [String] = []
-    var retrySendTransactionIDClosure: ((String) async -> Void)?
-
-    func retrySend(transactionID: String) async {
-        retrySendTransactionIDCallsCount += 1
-        retrySendTransactionIDReceivedTransactionID = transactionID
-        retrySendTransactionIDReceivedInvocations.append(transactionID)
-        await retrySendTransactionIDClosure?(transactionID)
-    }
    //MARK: - paginateBackwards

    var paginateBackwardsRequestSizeUnderlyingCallsCount = 0
@@ -11536,6 +11424,142 @@ class TimelineProxyMock: TimelineProxyProtocol {
            return paginateForwardsRequestSizeReturnValue
        }
    }
+    //MARK: - edit
+
+    var editMessageHtmlIntentionalMentionsUnderlyingCallsCount = 0
+    var editMessageHtmlIntentionalMentionsCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return editMessageHtmlIntentionalMentionsUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = editMessageHtmlIntentionalMentionsUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                editMessageHtmlIntentionalMentionsUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    editMessageHtmlIntentionalMentionsUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    var editMessageHtmlIntentionalMentionsCalled: Bool {
+        return editMessageHtmlIntentionalMentionsCallsCount > 0
+    }
+    var editMessageHtmlIntentionalMentionsReceivedArguments: (timelineItemID: TimelineItemIdentifier, message: String, html: String?, intentionalMentions: IntentionalMentions)?
+    var editMessageHtmlIntentionalMentionsReceivedInvocations: [(timelineItemID: TimelineItemIdentifier, message: String, html: String?, intentionalMentions: IntentionalMentions)] = []
+
+    var editMessageHtmlIntentionalMentionsUnderlyingReturnValue: Result<Void, TimelineProxyError>!
+    var editMessageHtmlIntentionalMentionsReturnValue: Result<Void, TimelineProxyError>! {
+        get {
+            if Thread.isMainThread {
+                return editMessageHtmlIntentionalMentionsUnderlyingReturnValue
+            } else {
+                var returnValue: Result<Void, TimelineProxyError>? = nil
+                DispatchQueue.main.sync {
+                    returnValue = editMessageHtmlIntentionalMentionsUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                editMessageHtmlIntentionalMentionsUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    editMessageHtmlIntentionalMentionsUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    var editMessageHtmlIntentionalMentionsClosure: ((TimelineItemIdentifier, String, String?, IntentionalMentions) async -> Result<Void, TimelineProxyError>)?
+
+    func edit(_ timelineItemID: TimelineItemIdentifier, message: String, html: String?, intentionalMentions: IntentionalMentions) async -> Result<Void, TimelineProxyError> {
+        editMessageHtmlIntentionalMentionsCallsCount += 1
+        editMessageHtmlIntentionalMentionsReceivedArguments = (timelineItemID: timelineItemID, message: message, html: html, intentionalMentions: intentionalMentions)
+        editMessageHtmlIntentionalMentionsReceivedInvocations.append((timelineItemID: timelineItemID, message: message, html: html, intentionalMentions: intentionalMentions))
+        if let editMessageHtmlIntentionalMentionsClosure = editMessageHtmlIntentionalMentionsClosure {
+            return await editMessageHtmlIntentionalMentionsClosure(timelineItemID, message, html, intentionalMentions)
+        } else {
+            return editMessageHtmlIntentionalMentionsReturnValue
+        }
+    }
+    //MARK: - redact
+
+    var redactReasonUnderlyingCallsCount = 0
+    var redactReasonCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return redactReasonUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = redactReasonUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                redactReasonUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    redactReasonUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    var redactReasonCalled: Bool {
+        return redactReasonCallsCount > 0
+    }
+    var redactReasonReceivedArguments: (timelineItemID: TimelineItemIdentifier, reason: String?)?
+    var redactReasonReceivedInvocations: [(timelineItemID: TimelineItemIdentifier, reason: String?)] = []
+
+    var redactReasonUnderlyingReturnValue: Result<Void, TimelineProxyError>!
+    var redactReasonReturnValue: Result<Void, TimelineProxyError>! {
+        get {
+            if Thread.isMainThread {
+                return redactReasonUnderlyingReturnValue
+            } else {
+                var returnValue: Result<Void, TimelineProxyError>? = nil
+                DispatchQueue.main.sync {
+                    returnValue = redactReasonUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                redactReasonUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    redactReasonUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    var redactReasonClosure: ((TimelineItemIdentifier, String?) async -> Result<Void, TimelineProxyError>)?
+
+    func redact(_ timelineItemID: TimelineItemIdentifier, reason: String?) async -> Result<Void, TimelineProxyError> {
+        redactReasonCallsCount += 1
+        redactReasonReceivedArguments = (timelineItemID: timelineItemID, reason: reason)
+        redactReasonReceivedInvocations.append((timelineItemID: timelineItemID, reason: reason))
+        if let redactReasonClosure = redactReasonClosure {
+            return await redactReasonClosure(timelineItemID, reason)
+        } else {
+            return redactReasonReturnValue
+        }
+    }
    //MARK: - sendAudio

    var sendAudioUrlAudioInfoProgressSubjectRequestHandleUnderlyingCallsCount = 0
@@ -4,6 +4,82 @@
 // swiftlint:disable all
 import Foundation
 import MatrixRustSDK
+open class AbortSendHandleSDKMock: MatrixRustSDK.AbortSendHandle {
+    init() {
+        super.init(noPointer: .init())
+    }
+
+    public required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
+        fatalError("init(unsafeFromRawPointer:) has not been implemented")
+    }
+
+    fileprivate var pointer: UnsafeMutableRawPointer!
+
+    //MARK: - abort
+
+    var abortUnderlyingCallsCount = 0
+    open var abortCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return abortUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = abortUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                abortUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    abortUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var abortCalled: Bool {
+        return abortCallsCount > 0
+    }
+
+    var abortUnderlyingReturnValue: Bool!
+    open var abortReturnValue: Bool! {
+        get {
+            if Thread.isMainThread {
+                return abortUnderlyingReturnValue
+            } else {
+                var returnValue: Bool? = nil
+                DispatchQueue.main.sync {
+                    returnValue = abortUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                abortUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    abortUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var abortClosure: (() async -> Bool)?
+
+    open override func abort() async -> Bool {
+        abortCallsCount += 1
+        if let abortClosure = abortClosure {
+            return await abortClosure()
+        } else {
+            return abortReturnValue
+        }
+    }
+}
 open class AuthenticationServiceSDKMock: MatrixRustSDK.AuthenticationService {
    init() {
        super.init(noPointer: .init())
@@ -889,6 +965,46 @@ open class ClientSDKMock: MatrixRustSDK.Client {
        }
    }

+    //MARK: - enableSendingQueue
+
+    var enableSendingQueueEnableUnderlyingCallsCount = 0
+    open var enableSendingQueueEnableCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return enableSendingQueueEnableUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = enableSendingQueueEnableUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                enableSendingQueueEnableUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    enableSendingQueueEnableUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var enableSendingQueueEnableCalled: Bool {
+        return enableSendingQueueEnableCallsCount > 0
+    }
+    open var enableSendingQueueEnableReceivedEnable: Bool?
+    open var enableSendingQueueEnableReceivedInvocations: [Bool] = []
+    open var enableSendingQueueEnableClosure: ((Bool) -> Void)?
+
+    open override func enableSendingQueue(enable: Bool) {
+        enableSendingQueueEnableCallsCount += 1
+        enableSendingQueueEnableReceivedEnable = enable
+        enableSendingQueueEnableReceivedInvocations.append(enable)
+        enableSendingQueueEnableClosure?(enable)
+    }
+
    //MARK: - encryption

    var encryptionUnderlyingCallsCount = 0
@@ -2593,15 +2709,15 @@ open class ClientSDKMock: MatrixRustSDK.Client {
            }
        }
    }
-    open var sessionClosure: (() async throws -> Session)?
+    open var sessionClosure: (() throws -> Session)?

-    open override func session() async throws -> Session {
+    open override func session() throws -> Session {
        if let error = sessionThrowableError {
            throw error
        }
        sessionCallsCount += 1
        if let sessionClosure = sessionClosure {
-            return try await sessionClosure()
+            return try sessionClosure()
        } else {
            return sessionReturnValue
        }
@@ -2877,6 +2993,75 @@ open class ClientSDKMock: MatrixRustSDK.Client {
        }
    }

+    //MARK: - subscribeToSendingQueueStatus
+
+    var subscribeToSendingQueueStatusListenerUnderlyingCallsCount = 0
+    open var subscribeToSendingQueueStatusListenerCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return subscribeToSendingQueueStatusListenerUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = subscribeToSendingQueueStatusListenerUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                subscribeToSendingQueueStatusListenerUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    subscribeToSendingQueueStatusListenerUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var subscribeToSendingQueueStatusListenerCalled: Bool {
+        return subscribeToSendingQueueStatusListenerCallsCount > 0
+    }
+    open var subscribeToSendingQueueStatusListenerReceivedListener: SendingQueueStatusListener?
+    open var subscribeToSendingQueueStatusListenerReceivedInvocations: [SendingQueueStatusListener] = []
+
+    var subscribeToSendingQueueStatusListenerUnderlyingReturnValue: TaskHandle!
+    open var subscribeToSendingQueueStatusListenerReturnValue: TaskHandle! {
+        get {
+            if Thread.isMainThread {
+                return subscribeToSendingQueueStatusListenerUnderlyingReturnValue
+            } else {
+                var returnValue: TaskHandle? = nil
+                DispatchQueue.main.sync {
+                    returnValue = subscribeToSendingQueueStatusListenerUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                subscribeToSendingQueueStatusListenerUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    subscribeToSendingQueueStatusListenerUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var subscribeToSendingQueueStatusListenerClosure: ((SendingQueueStatusListener) -> TaskHandle)?
+
+    open override func subscribeToSendingQueueStatus(listener: SendingQueueStatusListener) -> TaskHandle {
+        subscribeToSendingQueueStatusListenerCallsCount += 1
+        subscribeToSendingQueueStatusListenerReceivedListener = listener
+        subscribeToSendingQueueStatusListenerReceivedInvocations.append(listener)
+        if let subscribeToSendingQueueStatusListenerClosure = subscribeToSendingQueueStatusListenerClosure {
+            return subscribeToSendingQueueStatusListenerClosure(listener)
+        } else {
+            return subscribeToSendingQueueStatusListenerReturnValue
+        }
+    }
+
    //MARK: - syncService

    var syncServiceUnderlyingCallsCount = 0
@@ -7398,6 +7583,71 @@ open class MessageSDKMock: MatrixRustSDK.Message {
        }
    }

+    //MARK: - content
+
+    var contentUnderlyingCallsCount = 0
+    open var contentCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return contentUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = contentUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                contentUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    contentUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var contentCalled: Bool {
+        return contentCallsCount > 0
+    }
+
+    var contentUnderlyingReturnValue: RoomMessageEventContentWithoutRelation!
+    open var contentReturnValue: RoomMessageEventContentWithoutRelation! {
+        get {
+            if Thread.isMainThread {
+                return contentUnderlyingReturnValue
+            } else {
+                var returnValue: RoomMessageEventContentWithoutRelation? = nil
+                DispatchQueue.main.sync {
+                    returnValue = contentUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                contentUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    contentUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var contentClosure: (() -> RoomMessageEventContentWithoutRelation)?
+
+    open override func content() -> RoomMessageEventContentWithoutRelation {
+        contentCallsCount += 1
+        if let contentClosure = contentClosure {
+            return contentClosure()
+        } else {
+            return contentReturnValue
+        }
+    }
+
    //MARK: - inReplyTo

    var inReplyToUnderlyingCallsCount = 0
@@ -13954,15 +14204,15 @@ open class RoomListItemSDKMock: MatrixRustSDK.RoomListItem {
            }
        }
    }
-    open var fullRoomClosure: (() async throws -> Room)?
+    open var fullRoomClosure: (() throws -> Room)?

-    open override func fullRoom() async throws -> Room {
+    open override func fullRoom() throws -> Room {
        if let error = fullRoomThrowableError {
            throw error
        }
        fullRoomCallsCount += 1
        if let fullRoomClosure = fullRoomClosure {
-            return try await fullRoomClosure()
+            return try fullRoomClosure()
        } else {
            return fullRoomReturnValue
        }
@@ -16307,46 +16557,6 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline {
        }
    }

-    //MARK: - cancelSend
-
-    var cancelSendTxnIdUnderlyingCallsCount = 0
-    open var cancelSendTxnIdCallsCount: Int {
-        get {
-            if Thread.isMainThread {
-                return cancelSendTxnIdUnderlyingCallsCount
-            } else {
-                var returnValue: Int? = nil
-                DispatchQueue.main.sync {
-                    returnValue = cancelSendTxnIdUnderlyingCallsCount
-                }
-
-                return returnValue!
-            }
-        }
-        set {
-            if Thread.isMainThread {
-                cancelSendTxnIdUnderlyingCallsCount = newValue
-            } else {
-                DispatchQueue.main.sync {
-                    cancelSendTxnIdUnderlyingCallsCount = newValue
-                }
-            }
-        }
-    }
-    open var cancelSendTxnIdCalled: Bool {
-        return cancelSendTxnIdCallsCount > 0
-    }
-    open var cancelSendTxnIdReceivedTxnId: String?
-    open var cancelSendTxnIdReceivedInvocations: [String] = []
-    open var cancelSendTxnIdClosure: ((String) -> Void)?
-
-    open override func cancelSend(txnId: String) {
-        cancelSendTxnIdCallsCount += 1
-        cancelSendTxnIdReceivedTxnId = txnId
-        cancelSendTxnIdReceivedInvocations.append(txnId)
-        cancelSendTxnIdClosure?(txnId)
-    }
-
    //MARK: - createPoll

    open var createPollQuestionAnswersMaxSelectionsPollKindThrowableError: Error?
@@ -16379,16 +16589,16 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline {
    }
    open var createPollQuestionAnswersMaxSelectionsPollKindReceivedArguments: (question: String, answers: [String], maxSelections: UInt8, pollKind: PollKind)?
    open var createPollQuestionAnswersMaxSelectionsPollKindReceivedInvocations: [(question: String, answers: [String], maxSelections: UInt8, pollKind: PollKind)] = []
-    open var createPollQuestionAnswersMaxSelectionsPollKindClosure: ((String, [String], UInt8, PollKind) throws -> Void)?
+    open var createPollQuestionAnswersMaxSelectionsPollKindClosure: ((String, [String], UInt8, PollKind) async throws -> Void)?

-    open override func createPoll(question: String, answers: [String], maxSelections: UInt8, pollKind: PollKind) throws {
+    open override func createPoll(question: String, answers: [String], maxSelections: UInt8, pollKind: PollKind) async throws {
        if let error = createPollQuestionAnswersMaxSelectionsPollKindThrowableError {
            throw error
        }
        createPollQuestionAnswersMaxSelectionsPollKindCallsCount += 1
        createPollQuestionAnswersMaxSelectionsPollKindReceivedArguments = (question: question, answers: answers, maxSelections: maxSelections, pollKind: pollKind)
        createPollQuestionAnswersMaxSelectionsPollKindReceivedInvocations.append((question: question, answers: answers, maxSelections: maxSelections, pollKind: pollKind))
-        try createPollQuestionAnswersMaxSelectionsPollKindClosure?(question, answers, maxSelections, pollKind)
+        try await createPollQuestionAnswersMaxSelectionsPollKindClosure?(question, answers, maxSelections, pollKind)
    }

    //MARK: - edit
@@ -16749,18 +16959,18 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline {
        }
    }

-    //MARK: - getTimelineEventContentByEventId
+    //MARK: - getEventTimelineItemByTransactionId

-    open var getTimelineEventContentByEventIdEventIdThrowableError: Error?
-    var getTimelineEventContentByEventIdEventIdUnderlyingCallsCount = 0
-    open var getTimelineEventContentByEventIdEventIdCallsCount: Int {
+    open var getEventTimelineItemByTransactionIdTransactionIdThrowableError: Error?
+    var getEventTimelineItemByTransactionIdTransactionIdUnderlyingCallsCount = 0
+    open var getEventTimelineItemByTransactionIdTransactionIdCallsCount: Int {
        get {
            if Thread.isMainThread {
-                return getTimelineEventContentByEventIdEventIdUnderlyingCallsCount
+                return getEventTimelineItemByTransactionIdTransactionIdUnderlyingCallsCount
            } else {
                var returnValue: Int? = nil
                DispatchQueue.main.sync {
-                    returnValue = getTimelineEventContentByEventIdEventIdUnderlyingCallsCount
+                    returnValue = getEventTimelineItemByTransactionIdTransactionIdUnderlyingCallsCount
                }

                return returnValue!
@@ -16768,29 +16978,29 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline {
        }
        set {
            if Thread.isMainThread {
-                getTimelineEventContentByEventIdEventIdUnderlyingCallsCount = newValue
+                getEventTimelineItemByTransactionIdTransactionIdUnderlyingCallsCount = newValue
            } else {
                DispatchQueue.main.sync {
-                    getTimelineEventContentByEventIdEventIdUnderlyingCallsCount = newValue
+                    getEventTimelineItemByTransactionIdTransactionIdUnderlyingCallsCount = newValue
                }
            }
        }
    }
-    open var getTimelineEventContentByEventIdEventIdCalled: Bool {
-        return getTimelineEventContentByEventIdEventIdCallsCount > 0
+    open var getEventTimelineItemByTransactionIdTransactionIdCalled: Bool {
+        return getEventTimelineItemByTransactionIdTransactionIdCallsCount > 0
    }
-    open var getTimelineEventContentByEventIdEventIdReceivedEventId: String?
-    open var getTimelineEventContentByEventIdEventIdReceivedInvocations: [String] = []
+    open var getEventTimelineItemByTransactionIdTransactionIdReceivedTransactionId: String?
+    open var getEventTimelineItemByTransactionIdTransactionIdReceivedInvocations: [String] = []

-    var getTimelineEventContentByEventIdEventIdUnderlyingReturnValue: RoomMessageEventContentWithoutRelation!
-    open var getTimelineEventContentByEventIdEventIdReturnValue: RoomMessageEventContentWithoutRelation! {
+    var getEventTimelineItemByTransactionIdTransactionIdUnderlyingReturnValue: EventTimelineItem!
+    open var getEventTimelineItemByTransactionIdTransactionIdReturnValue: EventTimelineItem! {
        get {
            if Thread.isMainThread {
-                return getTimelineEventContentByEventIdEventIdUnderlyingReturnValue
+                return getEventTimelineItemByTransactionIdTransactionIdUnderlyingReturnValue
            } else {
-                var returnValue: RoomMessageEventContentWithoutRelation? = nil
+                var returnValue: EventTimelineItem? = nil
                DispatchQueue.main.sync {
-                    returnValue = getTimelineEventContentByEventIdEventIdUnderlyingReturnValue
+                    returnValue = getEventTimelineItemByTransactionIdTransactionIdUnderlyingReturnValue
                }

                return returnValue!
@@ -16798,27 +17008,27 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline {
        }
        set {
            if Thread.isMainThread {
-                getTimelineEventContentByEventIdEventIdUnderlyingReturnValue = newValue
+                getEventTimelineItemByTransactionIdTransactionIdUnderlyingReturnValue = newValue
            } else {
                DispatchQueue.main.sync {
-                    getTimelineEventContentByEventIdEventIdUnderlyingReturnValue = newValue
+                    getEventTimelineItemByTransactionIdTransactionIdUnderlyingReturnValue = newValue
                }
            }
        }
    }
-    open var getTimelineEventContentByEventIdEventIdClosure: ((String) async throws -> RoomMessageEventContentWithoutRelation)?
+    open var getEventTimelineItemByTransactionIdTransactionIdClosure: ((String) async throws -> EventTimelineItem)?

-    open override func getTimelineEventContentByEventId(eventId: String) async throws -> RoomMessageEventContentWithoutRelation {
-        if let error = getTimelineEventContentByEventIdEventIdThrowableError {
+    open override func getEventTimelineItemByTransactionId(transactionId: String) async throws -> EventTimelineItem {
+        if let error = getEventTimelineItemByTransactionIdTransactionIdThrowableError {
            throw error
        }
-        getTimelineEventContentByEventIdEventIdCallsCount += 1
-        getTimelineEventContentByEventIdEventIdReceivedEventId = eventId
-        getTimelineEventContentByEventIdEventIdReceivedInvocations.append(eventId)
-        if let getTimelineEventContentByEventIdEventIdClosure = getTimelineEventContentByEventIdEventIdClosure {
-            return try await getTimelineEventContentByEventIdEventIdClosure(eventId)
+        getEventTimelineItemByTransactionIdTransactionIdCallsCount += 1
+        getEventTimelineItemByTransactionIdTransactionIdReceivedTransactionId = transactionId
+        getEventTimelineItemByTransactionIdTransactionIdReceivedInvocations.append(transactionId)
+        if let getEventTimelineItemByTransactionIdTransactionIdClosure = getEventTimelineItemByTransactionIdTransactionIdClosure {
+            return try await getEventTimelineItemByTransactionIdTransactionIdClosure(transactionId)
        } else {
-            return getTimelineEventContentByEventIdEventIdReturnValue
+            return getEventTimelineItemByTransactionIdTransactionIdReturnValue
        }
    }

@@ -17004,6 +17214,79 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline {
        }
    }

+    //MARK: - redactEvent
+
+    open var redactEventItemReasonThrowableError: Error?
+    var redactEventItemReasonUnderlyingCallsCount = 0
+    open var redactEventItemReasonCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return redactEventItemReasonUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = redactEventItemReasonUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                redactEventItemReasonUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    redactEventItemReasonUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var redactEventItemReasonCalled: Bool {
+        return redactEventItemReasonCallsCount > 0
+    }
+    open var redactEventItemReasonReceivedArguments: (item: EventTimelineItem, reason: String?)?
+    open var redactEventItemReasonReceivedInvocations: [(item: EventTimelineItem, reason: String?)] = []
+
+    var redactEventItemReasonUnderlyingReturnValue: Bool!
+    open var redactEventItemReasonReturnValue: Bool! {
+        get {
+            if Thread.isMainThread {
+                return redactEventItemReasonUnderlyingReturnValue
+            } else {
+                var returnValue: Bool? = nil
+                DispatchQueue.main.sync {
+                    returnValue = redactEventItemReasonUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                redactEventItemReasonUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    redactEventItemReasonUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var redactEventItemReasonClosure: ((EventTimelineItem, String?) async throws -> Bool)?
+
+    open override func redactEvent(item: EventTimelineItem, reason: String?) async throws -> Bool {
+        if let error = redactEventItemReasonThrowableError {
+            throw error
+        }
+        redactEventItemReasonCallsCount += 1
+        redactEventItemReasonReceivedArguments = (item: item, reason: reason)
+        redactEventItemReasonReceivedInvocations.append((item: item, reason: reason))
+        if let redactEventItemReasonClosure = redactEventItemReasonClosure {
+            return try await redactEventItemReasonClosure(item, reason)
+        } else {
+            return redactEventItemReasonReturnValue
+        }
+    }
+
    //MARK: - retryDecryption

    var retryDecryptionSessionIdsUnderlyingCallsCount = 0
@@ -17044,48 +17327,9 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline {
        retryDecryptionSessionIdsClosure?(sessionIds)
    }

-    //MARK: - retrySend
-
-    var retrySendTxnIdUnderlyingCallsCount = 0
-    open var retrySendTxnIdCallsCount: Int {
-        get {
-            if Thread.isMainThread {
-                return retrySendTxnIdUnderlyingCallsCount
-            } else {
-                var returnValue: Int? = nil
-                DispatchQueue.main.sync {
-                    returnValue = retrySendTxnIdUnderlyingCallsCount
-                }
-
-                return returnValue!
-            }
-        }
-        set {
-            if Thread.isMainThread {
-                retrySendTxnIdUnderlyingCallsCount = newValue
-            } else {
-                DispatchQueue.main.sync {
-                    retrySendTxnIdUnderlyingCallsCount = newValue
-                }
-            }
-        }
-    }
-    open var retrySendTxnIdCalled: Bool {
-        return retrySendTxnIdCallsCount > 0
-    }
-    open var retrySendTxnIdReceivedTxnId: String?
-    open var retrySendTxnIdReceivedInvocations: [String] = []
-    open var retrySendTxnIdClosure: ((String) -> Void)?
-
-    open override func retrySend(txnId: String) {
-        retrySendTxnIdCallsCount += 1
-        retrySendTxnIdReceivedTxnId = txnId
-        retrySendTxnIdReceivedInvocations.append(txnId)
-        retrySendTxnIdClosure?(txnId)
-    }
-
    //MARK: - send

+    open var sendMsgThrowableError: Error?
    var sendMsgUnderlyingCallsCount = 0
    open var sendMsgCallsCount: Int {
        get {
@@ -17115,13 +17359,45 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline {
    }
    open var sendMsgReceivedMsg: RoomMessageEventContentWithoutRelation?
    open var sendMsgReceivedInvocations: [RoomMessageEventContentWithoutRelation] = []
-    open var sendMsgClosure: ((RoomMessageEventContentWithoutRelation) -> Void)?

-    open override func send(msg: RoomMessageEventContentWithoutRelation) {
+    var sendMsgUnderlyingReturnValue: AbortSendHandle!
+    open var sendMsgReturnValue: AbortSendHandle! {
+        get {
+            if Thread.isMainThread {
+                return sendMsgUnderlyingReturnValue
+            } else {
+                var returnValue: AbortSendHandle? = nil
+                DispatchQueue.main.sync {
+                    returnValue = sendMsgUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                sendMsgUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    sendMsgUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var sendMsgClosure: ((RoomMessageEventContentWithoutRelation) async throws -> AbortSendHandle)?
+
+    open override func send(msg: RoomMessageEventContentWithoutRelation) async throws -> AbortSendHandle {
+        if let error = sendMsgThrowableError {
+            throw error
+        }
        sendMsgCallsCount += 1
        sendMsgReceivedMsg = msg
        sendMsgReceivedInvocations.append(msg)
-        sendMsgClosure?(msg)
+        if let sendMsgClosure = sendMsgClosure {
+            return try await sendMsgClosure(msg)
+        } else {
+            return sendMsgReturnValue
+        }
    }

    //MARK: - sendAudio
@@ -17362,13 +17638,13 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline {
    }
    open var sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeReceivedArguments: (body: String, geoUri: String, description: String?, zoomLevel: UInt8?, assetType: AssetType?)?
    open var sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeReceivedInvocations: [(body: String, geoUri: String, description: String?, zoomLevel: UInt8?, assetType: AssetType?)] = []
-    open var sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeClosure: ((String, String, String?, UInt8?, AssetType?) -> Void)?
+    open var sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeClosure: ((String, String, String?, UInt8?, AssetType?) async -> Void)?

-    open override func sendLocation(body: String, geoUri: String, description: String?, zoomLevel: UInt8?, assetType: AssetType?) {
+    open override func sendLocation(body: String, geoUri: String, description: String?, zoomLevel: UInt8?, assetType: AssetType?) async {
        sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeCallsCount += 1
        sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeReceivedArguments = (body: body, geoUri: geoUri, description: description, zoomLevel: zoomLevel, assetType: assetType)
        sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeReceivedInvocations.append((body: body, geoUri: geoUri, description: description, zoomLevel: zoomLevel, assetType: assetType))
-        sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeClosure?(body, geoUri, description, zoomLevel, assetType)
+        await sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeClosure?(body, geoUri, description, zoomLevel, assetType)
    }

    //MARK: - sendPollResponse
@@ -17403,16 +17679,16 @@ open class TimelineSDKMock: MatrixRustSDK.Timeline {
    }
    open var sendPollResponsePollStartIdAnswersReceivedArguments: (pollStartId: String, answers: [String])?
    open var sendPollResponsePollStartIdAnswersReceivedInvocations: [(pollStartId: String, answers: [String])] = []
-    open var sendPollResponsePollStartIdAnswersClosure: ((String, [String]) throws -> Void)?
+    open var sendPollResponsePollStartIdAnswersClosure: ((String, [String]) async throws -> Void)?

-    open override func sendPollResponse(pollStartId: String, answers: [String]) throws {
+    open override func sendPollResponse(pollStartId: String, answers: [String]) async throws {
        if let error = sendPollResponsePollStartIdAnswersThrowableError {
            throw error
        }
        sendPollResponsePollStartIdAnswersCallsCount += 1
        sendPollResponsePollStartIdAnswersReceivedArguments = (pollStartId: pollStartId, answers: answers)
        sendPollResponsePollStartIdAnswersReceivedInvocations.append((pollStartId: pollStartId, answers: answers))
-        try sendPollResponsePollStartIdAnswersClosure?(pollStartId, answers)
+        try await sendPollResponsePollStartIdAnswersClosure?(pollStartId, answers)
    }

    //MARK: - sendReadReceipt
@@ -41,7 +41,6 @@ struct RoomProxyMockConfiguration {
    
    func makeTimeline() -> TimelineProxyMock {
        let timeline = TimelineProxyMock()
-        timeline.underlyingActions = Empty(completeImmediately: false).eraseToAnyPublisher()
        timeline.sendMessageEventContentReturnValue = .success(())
        
        let timelineProvider = RoomTimelineProviderMock()