Adopt sliding sync versions for client Restoration.

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -1925,6 +1925,28 @@ class ClientProxyMock: ClientProxyProtocol {
         set(value) { underlyingHomeserver = value }
     }
     var underlyingHomeserver: String!
+    var slidingSyncVersion: SlidingSyncVersion {
+        get { return underlyingSlidingSyncVersion }
+        set(value) { underlyingSlidingSyncVersion = value }
+    }
+    var underlyingSlidingSyncVersion: SlidingSyncVersion!
+    var availableSlidingSyncVersionsCallsCount = 0
+    var availableSlidingSyncVersionsCalled: Bool {
+        return availableSlidingSyncVersionsCallsCount > 0
+    }
+
+    var availableSlidingSyncVersions: [SlidingSyncVersion] {
+        get async {
+            availableSlidingSyncVersionsCallsCount += 1
+            if let availableSlidingSyncVersionsClosure = availableSlidingSyncVersionsClosure {
+                return await availableSlidingSyncVersionsClosure()
+            } else {
+                return underlyingAvailableSlidingSyncVersions
+            }
+        }
+    }
+    var underlyingAvailableSlidingSyncVersions: [SlidingSyncVersion]!
+    var availableSlidingSyncVersionsClosure: (() async -> [SlidingSyncVersion])?
     var userIDServerName: String?
     var userDisplayNamePublisher: CurrentValuePublisher<String?, Never> {
         get { return underlyingUserDisplayNamePublisher }

ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift

@@ -207,6 +207,71 @@ open class ClientSDKMock: MatrixRustSDK.Client {
         }
     }
 
+    //MARK: - availableSlidingSyncVersions
+
+    var availableSlidingSyncVersionsUnderlyingCallsCount = 0
+    open var availableSlidingSyncVersionsCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return availableSlidingSyncVersionsUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = availableSlidingSyncVersionsUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                availableSlidingSyncVersionsUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    availableSlidingSyncVersionsUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var availableSlidingSyncVersionsCalled: Bool {
+        return availableSlidingSyncVersionsCallsCount > 0
+    }
+
+    var availableSlidingSyncVersionsUnderlyingReturnValue: [SlidingSyncVersion]!
+    open var availableSlidingSyncVersionsReturnValue: [SlidingSyncVersion]! {
+        get {
+            if Thread.isMainThread {
+                return availableSlidingSyncVersionsUnderlyingReturnValue
+            } else {
+                var returnValue: [SlidingSyncVersion]? = nil
+                DispatchQueue.main.sync {
+                    returnValue = availableSlidingSyncVersionsUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                availableSlidingSyncVersionsUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    availableSlidingSyncVersionsUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var availableSlidingSyncVersionsClosure: (() async -> [SlidingSyncVersion])?
+
+    open override func availableSlidingSyncVersions() async -> [SlidingSyncVersion] {
+        availableSlidingSyncVersionsCallsCount += 1
+        if let availableSlidingSyncVersionsClosure = availableSlidingSyncVersionsClosure {
+            return await availableSlidingSyncVersionsClosure()
+        } else {
+            return availableSlidingSyncVersionsReturnValue
+        }
+    }
+
     //MARK: - avatarUrl
 
     open var avatarUrlThrowableError: Error?
@@ -1955,6 +2020,52 @@ open class ClientSDKMock: MatrixRustSDK.Client {
         try await loginUsernamePasswordInitialDeviceNameDeviceIdClosure?(username, password, initialDeviceName, deviceId)
     }
 
+    //MARK: - loginWithEmail
+
+    open var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdThrowableError: Error?
+    var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingCallsCount = 0
+    open var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdCalled: Bool {
+        return loginWithEmailEmailPasswordInitialDeviceNameDeviceIdCallsCount > 0
+    }
+    open var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdReceivedArguments: (email: String, password: String, initialDeviceName: String?, deviceId: String?)?
+    open var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdReceivedInvocations: [(email: String, password: String, initialDeviceName: String?, deviceId: String?)] = []
+    open var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdClosure: ((String, String, String?, String?) async throws -> Void)?
+
+    open override func loginWithEmail(email: String, password: String, initialDeviceName: String?, deviceId: String?) async throws {
+        if let error = loginWithEmailEmailPasswordInitialDeviceNameDeviceIdThrowableError {
+            throw error
+        }
+        loginWithEmailEmailPasswordInitialDeviceNameDeviceIdCallsCount += 1
+        loginWithEmailEmailPasswordInitialDeviceNameDeviceIdReceivedArguments = (email: email, password: password, initialDeviceName: initialDeviceName, deviceId: deviceId)
+        DispatchQueue.main.async {
+            self.loginWithEmailEmailPasswordInitialDeviceNameDeviceIdReceivedInvocations.append((email: email, password: password, initialDeviceName: initialDeviceName, deviceId: deviceId))
+        }
+        try await loginWithEmailEmailPasswordInitialDeviceNameDeviceIdClosure?(email, password, initialDeviceName, deviceId)
+    }
+
     //MARK: - loginWithOidcCallback
 
     open var loginWithOidcCallbackAuthorizationDataCallbackUrlThrowableError: Error?
@@ -2829,6 +2940,71 @@ open class ClientSDKMock: MatrixRustSDK.Client {
         try await setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangClosure?(identifiers, kind, appDisplayName, deviceDisplayName, profileTag, lang)
     }
 
+    //MARK: - slidingSyncVersion
+
+    var slidingSyncVersionUnderlyingCallsCount = 0
+    open var slidingSyncVersionCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return slidingSyncVersionUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = slidingSyncVersionUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                slidingSyncVersionUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    slidingSyncVersionUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var slidingSyncVersionCalled: Bool {
+        return slidingSyncVersionCallsCount > 0
+    }
+
+    var slidingSyncVersionUnderlyingReturnValue: SlidingSyncVersion!
+    open var slidingSyncVersionReturnValue: SlidingSyncVersion! {
+        get {
+            if Thread.isMainThread {
+                return slidingSyncVersionUnderlyingReturnValue
+            } else {
+                var returnValue: SlidingSyncVersion? = nil
+                DispatchQueue.main.sync {
+                    returnValue = slidingSyncVersionUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                slidingSyncVersionUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    slidingSyncVersionUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var slidingSyncVersionClosure: (() -> SlidingSyncVersion)?
+
+    open override func slidingSyncVersion() -> SlidingSyncVersion {
+        slidingSyncVersionCallsCount += 1
+        if let slidingSyncVersionClosure = slidingSyncVersionClosure {
+            return slidingSyncVersionClosure()
+        } else {
+            return slidingSyncVersionReturnValue
+        }
+    }
+
     //MARK: - startSsoLogin
 
     open var startSsoLoginRedirectUrlIdpIdThrowableError: Error?
@@ -4526,71 +4702,6 @@ open class ClientBuilderSDKMock: MatrixRustSDK.ClientBuilder {
         }
     }
 
-    //MARK: - requiresSlidingSync
-
-    var requiresSlidingSyncUnderlyingCallsCount = 0
-    open var requiresSlidingSyncCallsCount: Int {
-        get {
-            if Thread.isMainThread {
-                return requiresSlidingSyncUnderlyingCallsCount
-            } else {
-                var returnValue: Int? = nil
-                DispatchQueue.main.sync {
-                    returnValue = requiresSlidingSyncUnderlyingCallsCount
-                }
-
-                return returnValue!
-            }
-        }
-        set {
-            if Thread.isMainThread {
-                requiresSlidingSyncUnderlyingCallsCount = newValue
-            } else {
-                DispatchQueue.main.sync {
-                    requiresSlidingSyncUnderlyingCallsCount = newValue
-                }
-            }
-        }
-    }
-    open var requiresSlidingSyncCalled: Bool {
-        return requiresSlidingSyncCallsCount > 0
-    }
-
-    var requiresSlidingSyncUnderlyingReturnValue: ClientBuilder!
-    open var requiresSlidingSyncReturnValue: ClientBuilder! {
-        get {
-            if Thread.isMainThread {
-                return requiresSlidingSyncUnderlyingReturnValue
-            } else {
-                var returnValue: ClientBuilder? = nil
-                DispatchQueue.main.sync {
-                    returnValue = requiresSlidingSyncUnderlyingReturnValue
-                }
-
-                return returnValue!
-            }
-        }
-        set {
-            if Thread.isMainThread {
-                requiresSlidingSyncUnderlyingReturnValue = newValue
-            } else {
-                DispatchQueue.main.sync {
-                    requiresSlidingSyncUnderlyingReturnValue = newValue
-                }
-            }
-        }
-    }
-    open var requiresSlidingSyncClosure: (() -> ClientBuilder)?
-
-    open override func requiresSlidingSync() -> ClientBuilder {
-        requiresSlidingSyncCallsCount += 1
-        if let requiresSlidingSyncClosure = requiresSlidingSyncClosure {
-            return requiresSlidingSyncClosure()
-        } else {
-            return requiresSlidingSyncReturnValue
-        }
-    }
-
     //MARK: - roomKeyRecipientStrategy
 
     var roomKeyRecipientStrategyStrategyUnderlyingCallsCount = 0
@@ -4833,8 +4944,8 @@ open class ClientBuilderSDKMock: MatrixRustSDK.ClientBuilder {
     open var sessionPathsDataPathCachePathCalled: Bool {
         return sessionPathsDataPathCachePathCallsCount > 0
     }
-    open var sessionPathsDataPathCachePathReceivedArguments: (dataPath: String, cachePath: String?)?
+    open var sessionPathsDataPathCachePathReceivedArguments: (dataPath: String, cachePath: String)?
-    open var sessionPathsDataPathCachePathReceivedInvocations: [(dataPath: String, cachePath: String?)] = []
+    open var sessionPathsDataPathCachePathReceivedInvocations: [(dataPath: String, cachePath: String)] = []
 
     var sessionPathsDataPathCachePathUnderlyingReturnValue: ClientBuilder!
     open var sessionPathsDataPathCachePathReturnValue: ClientBuilder! {
@@ -4860,9 +4971,9 @@ open class ClientBuilderSDKMock: MatrixRustSDK.ClientBuilder {
             }
         }
     }
-    open var sessionPathsDataPathCachePathClosure: ((String, String?) -> ClientBuilder)?
+    open var sessionPathsDataPathCachePathClosure: ((String, String) -> ClientBuilder)?
 
-    open override func sessionPaths(dataPath: String, cachePath: String?) -> ClientBuilder {
+    open override func sessionPaths(dataPath: String, cachePath: String) -> ClientBuilder {
         sessionPathsDataPathCachePathCallsCount += 1
         sessionPathsDataPathCachePathReceivedArguments = (dataPath: dataPath, cachePath: cachePath)
         DispatchQueue.main.async {
@@ -4946,17 +5057,17 @@ open class ClientBuilderSDKMock: MatrixRustSDK.ClientBuilder {
         }
     }
 
-    //MARK: - simplifiedSlidingSync
+    //MARK: - slidingSyncVersionBuilder
 
-    var simplifiedSlidingSyncEnableUnderlyingCallsCount = 0
+    var slidingSyncVersionBuilderVersionBuilderUnderlyingCallsCount = 0
-    open var simplifiedSlidingSyncEnableCallsCount: Int {
+    open var slidingSyncVersionBuilderVersionBuilderCallsCount: Int {
         get {
             if Thread.isMainThread {
-                return simplifiedSlidingSyncEnableUnderlyingCallsCount
+                return slidingSyncVersionBuilderVersionBuilderUnderlyingCallsCount
             } else {
                 var returnValue: Int? = nil
                 DispatchQueue.main.sync {
-                    returnValue = simplifiedSlidingSyncEnableUnderlyingCallsCount
+                    returnValue = slidingSyncVersionBuilderVersionBuilderUnderlyingCallsCount
                 }
 
                 return returnValue!
@@ -4964,29 +5075,29 @@ open class ClientBuilderSDKMock: MatrixRustSDK.ClientBuilder {
         }
         set {
             if Thread.isMainThread {
-                simplifiedSlidingSyncEnableUnderlyingCallsCount = newValue
+                slidingSyncVersionBuilderVersionBuilderUnderlyingCallsCount = newValue
             } else {
                 DispatchQueue.main.sync {
-                    simplifiedSlidingSyncEnableUnderlyingCallsCount = newValue
+                    slidingSyncVersionBuilderVersionBuilderUnderlyingCallsCount = newValue
                 }
             }
         }
     }
-    open var simplifiedSlidingSyncEnableCalled: Bool {
+    open var slidingSyncVersionBuilderVersionBuilderCalled: Bool {
-        return simplifiedSlidingSyncEnableCallsCount > 0
+        return slidingSyncVersionBuilderVersionBuilderCallsCount > 0
     }
-    open var simplifiedSlidingSyncEnableReceivedEnable: Bool?
+    open var slidingSyncVersionBuilderVersionBuilderReceivedVersionBuilder: SlidingSyncVersionBuilder?
-    open var simplifiedSlidingSyncEnableReceivedInvocations: [Bool] = []
+    open var slidingSyncVersionBuilderVersionBuilderReceivedInvocations: [SlidingSyncVersionBuilder] = []
 
-    var simplifiedSlidingSyncEnableUnderlyingReturnValue: ClientBuilder!
+    var slidingSyncVersionBuilderVersionBuilderUnderlyingReturnValue: ClientBuilder!
-    open var simplifiedSlidingSyncEnableReturnValue: ClientBuilder! {
+    open var slidingSyncVersionBuilderVersionBuilderReturnValue: ClientBuilder! {
         get {
             if Thread.isMainThread {
-                return simplifiedSlidingSyncEnableUnderlyingReturnValue
+                return slidingSyncVersionBuilderVersionBuilderUnderlyingReturnValue
             } else {
                 var returnValue: ClientBuilder? = nil
                 DispatchQueue.main.sync {
-                    returnValue = simplifiedSlidingSyncEnableUnderlyingReturnValue
+                    returnValue = slidingSyncVersionBuilderVersionBuilderUnderlyingReturnValue
                 }
 
                 return returnValue!
@@ -4994,97 +5105,26 @@ open class ClientBuilderSDKMock: MatrixRustSDK.ClientBuilder {
         }
         set {
             if Thread.isMainThread {
-                simplifiedSlidingSyncEnableUnderlyingReturnValue = newValue
+                slidingSyncVersionBuilderVersionBuilderUnderlyingReturnValue = newValue
             } else {
                 DispatchQueue.main.sync {
-                    simplifiedSlidingSyncEnableUnderlyingReturnValue = newValue
+                    slidingSyncVersionBuilderVersionBuilderUnderlyingReturnValue = newValue
                 }
             }
         }
     }
-    open var simplifiedSlidingSyncEnableClosure: ((Bool) -> ClientBuilder)?
+    open var slidingSyncVersionBuilderVersionBuilderClosure: ((SlidingSyncVersionBuilder) -> ClientBuilder)?
 
-    open override func simplifiedSlidingSync(enable: Bool) -> ClientBuilder {
+    open override func slidingSyncVersionBuilder(versionBuilder: SlidingSyncVersionBuilder) -> ClientBuilder {
-        simplifiedSlidingSyncEnableCallsCount += 1
+        slidingSyncVersionBuilderVersionBuilderCallsCount += 1
-        simplifiedSlidingSyncEnableReceivedEnable = enable
+        slidingSyncVersionBuilderVersionBuilderReceivedVersionBuilder = versionBuilder
         DispatchQueue.main.async {
-            self.simplifiedSlidingSyncEnableReceivedInvocations.append(enable)
+            self.slidingSyncVersionBuilderVersionBuilderReceivedInvocations.append(versionBuilder)
         }
-        if let simplifiedSlidingSyncEnableClosure = simplifiedSlidingSyncEnableClosure {
+        if let slidingSyncVersionBuilderVersionBuilderClosure = slidingSyncVersionBuilderVersionBuilderClosure {
-            return simplifiedSlidingSyncEnableClosure(enable)
+            return slidingSyncVersionBuilderVersionBuilderClosure(versionBuilder)
         } else {
-            return simplifiedSlidingSyncEnableReturnValue
+            return slidingSyncVersionBuilderVersionBuilderReturnValue
-        }
-    }
-
-    //MARK: - slidingSyncProxy
-
-    var slidingSyncProxySlidingSyncProxyUnderlyingCallsCount = 0
-    open var slidingSyncProxySlidingSyncProxyCallsCount: Int {
-        get {
-            if Thread.isMainThread {
-                return slidingSyncProxySlidingSyncProxyUnderlyingCallsCount
-            } else {
-                var returnValue: Int? = nil
-                DispatchQueue.main.sync {
-                    returnValue = slidingSyncProxySlidingSyncProxyUnderlyingCallsCount
-                }
-
-                return returnValue!
-            }
-        }
-        set {
-            if Thread.isMainThread {
-                slidingSyncProxySlidingSyncProxyUnderlyingCallsCount = newValue
-            } else {
-                DispatchQueue.main.sync {
-                    slidingSyncProxySlidingSyncProxyUnderlyingCallsCount = newValue
-                }
-            }
-        }
-    }
-    open var slidingSyncProxySlidingSyncProxyCalled: Bool {
-        return slidingSyncProxySlidingSyncProxyCallsCount > 0
-    }
-    open var slidingSyncProxySlidingSyncProxyReceivedSlidingSyncProxy: String?
-    open var slidingSyncProxySlidingSyncProxyReceivedInvocations: [String?] = []
-
-    var slidingSyncProxySlidingSyncProxyUnderlyingReturnValue: ClientBuilder!
-    open var slidingSyncProxySlidingSyncProxyReturnValue: ClientBuilder! {
-        get {
-            if Thread.isMainThread {
-                return slidingSyncProxySlidingSyncProxyUnderlyingReturnValue
-            } else {
-                var returnValue: ClientBuilder? = nil
-                DispatchQueue.main.sync {
-                    returnValue = slidingSyncProxySlidingSyncProxyUnderlyingReturnValue
-                }
-
-                return returnValue!
-            }
-        }
-        set {
-            if Thread.isMainThread {
-                slidingSyncProxySlidingSyncProxyUnderlyingReturnValue = newValue
-            } else {
-                DispatchQueue.main.sync {
-                    slidingSyncProxySlidingSyncProxyUnderlyingReturnValue = newValue
-                }
-            }
-        }
-    }
-    open var slidingSyncProxySlidingSyncProxyClosure: ((String?) -> ClientBuilder)?
-
-    open override func slidingSyncProxy(slidingSyncProxy: String?) -> ClientBuilder {
-        slidingSyncProxySlidingSyncProxyCallsCount += 1
-        slidingSyncProxySlidingSyncProxyReceivedSlidingSyncProxy = slidingSyncProxy
-        DispatchQueue.main.async {
-            self.slidingSyncProxySlidingSyncProxyReceivedInvocations.append(slidingSyncProxy)
-        }
-        if let slidingSyncProxySlidingSyncProxyClosure = slidingSyncProxySlidingSyncProxyClosure {
-            return slidingSyncProxySlidingSyncProxyClosure(slidingSyncProxy)
-        } else {
-            return slidingSyncProxySlidingSyncProxyReturnValue
         }
     }
 
@@ -7546,17 +7586,17 @@ open class HomeserverLoginDetailsSDKMock: MatrixRustSDK.HomeserverLoginDetails {
 
     fileprivate var pointer: UnsafeMutableRawPointer!
 
-    //MARK: - slidingSyncProxy
+    //MARK: - slidingSyncVersion
 
-    var slidingSyncProxyUnderlyingCallsCount = 0
+    var slidingSyncVersionUnderlyingCallsCount = 0
-    open var slidingSyncProxyCallsCount: Int {
+    open var slidingSyncVersionCallsCount: Int {
         get {
             if Thread.isMainThread {
-                return slidingSyncProxyUnderlyingCallsCount
+                return slidingSyncVersionUnderlyingCallsCount
             } else {
                 var returnValue: Int? = nil
                 DispatchQueue.main.sync {
-                    returnValue = slidingSyncProxyUnderlyingCallsCount
+                    returnValue = slidingSyncVersionUnderlyingCallsCount
                 }
 
                 return returnValue!
@@ -7564,27 +7604,27 @@ open class HomeserverLoginDetailsSDKMock: MatrixRustSDK.HomeserverLoginDetails {
         }
         set {
             if Thread.isMainThread {
-                slidingSyncProxyUnderlyingCallsCount = newValue
+                slidingSyncVersionUnderlyingCallsCount = newValue
             } else {
                 DispatchQueue.main.sync {
-                    slidingSyncProxyUnderlyingCallsCount = newValue
+                    slidingSyncVersionUnderlyingCallsCount = newValue
                 }
             }
         }
     }
-    open var slidingSyncProxyCalled: Bool {
+    open var slidingSyncVersionCalled: Bool {
-        return slidingSyncProxyCallsCount > 0
+        return slidingSyncVersionCallsCount > 0
     }
 
-    var slidingSyncProxyUnderlyingReturnValue: String?
+    var slidingSyncVersionUnderlyingReturnValue: SlidingSyncVersion!
-    open var slidingSyncProxyReturnValue: String? {
+    open var slidingSyncVersionReturnValue: SlidingSyncVersion! {
         get {
             if Thread.isMainThread {
-                return slidingSyncProxyUnderlyingReturnValue
+                return slidingSyncVersionUnderlyingReturnValue
             } else {
-                var returnValue: String?? = nil
+                var returnValue: SlidingSyncVersion? = nil
                 DispatchQueue.main.sync {
-                    returnValue = slidingSyncProxyUnderlyingReturnValue
+                    returnValue = slidingSyncVersionUnderlyingReturnValue
                 }
 
                 return returnValue!
@@ -7592,22 +7632,22 @@ open class HomeserverLoginDetailsSDKMock: MatrixRustSDK.HomeserverLoginDetails {
         }
         set {
             if Thread.isMainThread {
-                slidingSyncProxyUnderlyingReturnValue = newValue
+                slidingSyncVersionUnderlyingReturnValue = newValue
             } else {
                 DispatchQueue.main.sync {
-                    slidingSyncProxyUnderlyingReturnValue = newValue
+                    slidingSyncVersionUnderlyingReturnValue = newValue
                 }
             }
         }
     }
-    open var slidingSyncProxyClosure: (() -> String?)?
+    open var slidingSyncVersionClosure: (() -> SlidingSyncVersion)?
 
-    open override func slidingSyncProxy() -> String? {
+    open override func slidingSyncVersion() -> SlidingSyncVersion {
-        slidingSyncProxyCallsCount += 1
+        slidingSyncVersionCallsCount += 1
-        if let slidingSyncProxyClosure = slidingSyncProxyClosure {
+        if let slidingSyncVersionClosure = slidingSyncVersionClosure {
-            return slidingSyncProxyClosure()
+            return slidingSyncVersionClosure()
         } else {
-            return slidingSyncProxyReturnValue
+            return slidingSyncVersionReturnValue
         }
     }
 
@@ -20676,6 +20716,71 @@ open class TimelineDiffSDKMock: MatrixRustSDK.TimelineDiff {
             return setReturnValue
         }
     }
+
+    //MARK: - truncate
+
+    var truncateUnderlyingCallsCount = 0
+    open var truncateCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return truncateUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = truncateUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                truncateUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    truncateUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var truncateCalled: Bool {
+        return truncateCallsCount > 0
+    }
+
+    var truncateUnderlyingReturnValue: UInt32?
+    open var truncateReturnValue: UInt32? {
+        get {
+            if Thread.isMainThread {
+                return truncateUnderlyingReturnValue
+            } else {
+                var returnValue: UInt32?? = nil
+                DispatchQueue.main.sync {
+                    returnValue = truncateUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                truncateUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    truncateUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var truncateClosure: (() -> UInt32?)?
+
+    open override func truncate() -> UInt32? {
+        truncateCallsCount += 1
+        if let truncateClosure = truncateClosure {
+            return truncateClosure()
+        } else {
+            return truncateReturnValue
+        }
+    }
 }
 open class TimelineEventSDKMock: MatrixRustSDK.TimelineEvent {
     init() {

ElementX/Sources/Services/Client/ClientProxy.swift

@@ -210,6 +210,16 @@ class ClientProxy: ClientProxyProtocol {
         client.homeserver()
     }
     
+    var slidingSyncVersion: SlidingSyncVersion {
+        client.slidingSyncVersion()
+    }
+    
+    var availableSlidingSyncVersions: [SlidingSyncVersion] {
+        get async {
+            await client.availableSlidingSyncVersions()
+        }
+    }
+    
     var userIDServerName: String? {
         do {
             return try client.userIdServerName()

ElementX/Sources/Services/Client/ClientProxyProtocol.swift

@@ -104,8 +104,11 @@ protocol ClientProxyProtocol: AnyObject, MediaLoaderProtocol {
 
     var homeserver: String { get }
     
+    var slidingSyncVersion: SlidingSyncVersion { get }
+    var availableSlidingSyncVersions: [SlidingSyncVersion] { get async }
+    
     var userIDServerName: String? { get }
-        
+    
     var userDisplayNamePublisher: CurrentValuePublisher<String?, Never> { get }
 
     var userAvatarURLPublisher: CurrentValuePublisher<URL?, Never> { get }

ElementX/Sources/Services/UserSession/RestorationToken.swift

@@ -54,14 +54,14 @@ extension RestorationToken: Codable {
 extension MatrixRustSDK.Session: Codable {
     public init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
+        let slidingSyncVersion: SlidingSyncVersion = try container.decodeIfPresent(String.self, forKey: .slidingSyncProxy).map { .proxy(url: $0) } ?? .native
         self = try .init(accessToken: container.decode(String.self, forKey: .accessToken),
                          refreshToken: container.decodeIfPresent(String.self, forKey: .refreshToken),
                          userId: container.decode(String.self, forKey: .userId),
                          deviceId: container.decode(String.self, forKey: .deviceId),
                          homeserverUrl: container.decode(String.self, forKey: .homeserverUrl),
                          oidcData: container.decodeIfPresent(String.self, forKey: .oidcData),
-                         // Note: the proxy is optional now that we support Simplified Sliding Sync.
+                         slidingSyncVersion: slidingSyncVersion)
-                         slidingSyncProxy: container.decodeIfPresent(String.self, forKey: .slidingSyncProxy))
     }
     
     public func encode(to encoder: Encoder) throws {
@@ -72,10 +72,17 @@ extension MatrixRustSDK.Session: Codable {
         try container.encode(deviceId, forKey: .deviceId)
         try container.encode(homeserverUrl, forKey: .homeserverUrl)
         try container.encode(oidcData, forKey: .oidcData)
-        try container.encode(slidingSyncProxy, forKey: .slidingSyncProxy)
+        try container.encode(slidingSyncVersion.proxyURL, forKey: .slidingSyncProxy)
     }
     
     enum CodingKeys: String, CodingKey {
         case accessToken, refreshToken, userId, deviceId, homeserverUrl, oidcData, slidingSyncProxy
     }
 }
+
+private extension SlidingSyncVersion {
+    var proxyURL: String? {
+        guard case let .proxy(url) = self else { return nil }
+        return url
+    }
+}

ElementX/Sources/Services/UserSession/UserSessionStore.swift

@@ -131,7 +131,7 @@ class UserSessionStore: UserSessionStoreProtocol {
         
         let builder = ClientBuilder
             .baseBuilder(httpProxy: URL(string: homeserverURL)?.globalProxy,
-                         slidingSync: appSettings.simplifiedSlidingSyncEnabled ? .simplified : .restored,
+                         slidingSync: .restored,
                          sessionDelegate: keychainController,
                          appHooks: appHooks)
             .sessionPaths(dataPath: credentials.restorationToken.sessionDirectory.path(percentEncoded: false),

NSE/Sources/NotificationServiceExtension.swift

@@ -88,7 +88,6 @@ class NotificationServiceExtension: UNNotificationServiceExtension {
                     do {
                         Self.userSession = try await NSEUserSession(credentials: credentials,
                                                                     clientSessionDelegate: keychainController,
-                                                                    simplifiedSlidingSyncEnabled: settings.simplifiedSlidingSyncEnabled,
                                                                     appHooks: appHooks)
                     } catch {
                         MXLog.error("Failed creating user session with error: \(error)")

NSE/Sources/Other/NSESettingsProtocol.swift

@@ -18,7 +18,6 @@ import Foundation
 
 protocol NSESettingsProtocol {
     var logLevel: TracingConfiguration.LogLevel { get }
-    var simplifiedSlidingSyncEnabled: Bool { get }
 }
 
 extension AppSettings: NSESettingsProtocol { }

NSE/Sources/Other/NSEUserSession.swift

@@ -26,7 +26,7 @@ final class NSEUserSession {
                                                                                networkMonitor: nil)
     private let delegateHandle: TaskHandle?
 
-    init(credentials: KeychainCredentials, clientSessionDelegate: ClientSessionDelegate, simplifiedSlidingSyncEnabled: Bool, appHooks: AppHooks) async throws {
+    init(credentials: KeychainCredentials, clientSessionDelegate: ClientSessionDelegate, appHooks: AppHooks) async throws {
         userID = credentials.userID
         if credentials.restorationToken.passphrase != nil {
             MXLog.info("Restoring client with encrypted store.")
@@ -36,7 +36,7 @@ final class NSEUserSession {
         let clientBuilder = ClientBuilder
             .baseBuilder(setupEncryption: false,
                          httpProxy: URL(string: homeserverURL)?.globalProxy,
-                         slidingSync: simplifiedSlidingSyncEnabled ? .simplified : .restored,
+                         slidingSync: .restored,
                          sessionDelegate: clientSessionDelegate,
                          appHooks: appHooks)
             .sessionPaths(dataPath: credentials.restorationToken.sessionDirectory.path(percentEncoded: false),

UnitTests/Sources/KeychainControllerTests.swift

@@ -39,7 +39,7 @@ class KeychainControllerTests: XCTestCase {
                                                                deviceId: "deviceId",
                                                                homeserverUrl: "homeserverUrl",
                                                                oidcData: "oidcData",
-                                                               slidingSyncProxy: "https://my.sync.proxy"),
+                                                               slidingSyncVersion: .proxy(url: "https://my.sync.proxy")),
                                                 sessionDirectory: .homeDirectory.appending(component: UUID().uuidString),
                                                 cacheDirectory: .homeDirectory.appending(component: UUID().uuidString),
                                                 passphrase: "passphrase",
@@ -59,7 +59,7 @@ class KeychainControllerTests: XCTestCase {
                                                                deviceId: "deviceId",
                                                                homeserverUrl: "homeserverUrl",
                                                                oidcData: "oidcData",
-                                                               slidingSyncProxy: "https://my.sync.proxy"),
+                                                               slidingSyncVersion: .proxy(url: "https://my.sync.proxy")),
                                                 sessionDirectory: .homeDirectory.appending(component: UUID().uuidString),
                                                 cacheDirectory: .homeDirectory.appending(component: UUID().uuidString),
                                                 passphrase: "passphrase",
@@ -85,7 +85,7 @@ class KeychainControllerTests: XCTestCase {
                                                                    deviceId: "deviceId",
                                                                    homeserverUrl: "homeserverUrl",
                                                                    oidcData: "oidcData",
-                                                                   slidingSyncProxy: "https://my.sync.proxy"),
+                                                                   slidingSyncVersion: .proxy(url: "https://my.sync.proxy")),
                                                     sessionDirectory: .homeDirectory.appending(component: UUID().uuidString),
                                                     cacheDirectory: .homeDirectory.appending(component: UUID().uuidString),
                                                     passphrase: "passphrase",
@@ -110,7 +110,7 @@ class KeychainControllerTests: XCTestCase {
                                                                    deviceId: "deviceId",
                                                                    homeserverUrl: "homeserverUrl",
                                                                    oidcData: "oidcData",
-                                                                   slidingSyncProxy: "https://my.sync.proxy"),
+                                                                   slidingSyncVersion: .proxy(url: "https://my.sync.proxy")),
                                                     sessionDirectory: .homeDirectory.appending(component: UUID().uuidString),
                                                     cacheDirectory: .homeDirectory.appending(component: UUID().uuidString),
                                                     passphrase: "passphrase",
@@ -143,7 +143,7 @@ class KeychainControllerTests: XCTestCase {
                                                                deviceId: "deviceId",
                                                                homeserverUrl: "homeserverUrl",
                                                                oidcData: "oidcData",
-                                                               slidingSyncProxy: nil),
+                                                               slidingSyncVersion: .native),
                                                 sessionDirectory: .homeDirectory.appending(component: UUID().uuidString),
                                                 cacheDirectory: .homeDirectory.appending(component: UUID().uuidString),
                                                 passphrase: "passphrase",

UnitTests/Sources/RestorationTokenTests.swift

@@ -28,7 +28,7 @@ class RestorationTokenTests: XCTestCase {
                                                                 deviceId: "D3V1C3",
                                                                 homeserverUrl: "https://matrix.example.com",
                                                                 oidcData: nil,
-                                                                slidingSyncProxy: "https://sync.example.com"))
+                                                                slidingSyncVersion: .proxy(url: "https://sync.example.com")))
         let data = try JSONEncoder().encode(originalToken)
         
         // When decoding the data to the current restoration token format.
@@ -53,7 +53,7 @@ class RestorationTokenTests: XCTestCase {
                                                                 deviceId: "D3V1C3",
                                                                 homeserverUrl: "https://matrix.example.com",
                                                                 oidcData: "data-from-mas",
-                                                                slidingSyncProxy: "https://sync.example.com"),
+                                                                slidingSyncVersion: .proxy(url: "https://sync.example.com")),
                                                sessionDirectory: .sessionsBaseDirectory.appending(component: sessionDirectoryName),
                                                passphrase: "passphrase",
                                                pusherNotificationClientIdentifier: "pusher-identifier")
@@ -81,7 +81,7 @@ class RestorationTokenTests: XCTestCase {
                                                               deviceId: "D3V1C3",
                                                               homeserverUrl: "https://matrix.example.com",
                                                               oidcData: "data-from-mas",
-                                                              slidingSyncProxy: nil),
+                                                              slidingSyncVersion: .native),
                                              sessionDirectory: .sessionsBaseDirectory.appending(component: sessionDirectoryName),
                                              cacheDirectory: .cachesBaseDirectory.appending(component: sessionDirectoryName),
                                              passphrase: "passphrase",