update Mobile SDK docs for new Seam prefixed names and latest api changes

Author: medmonds

docs/capability-guides/mobile-access/mobile-device-sdks/handling-system-permissions.md

@@ -2,23 +2,17 @@
 
 Missing or required system permissions (Bluetooth, internet connectivity, etc.) are surfaced as `CredentialError.userInteractionRequired(action)` entries on each credential’s `errors` array. Observe these errors after activation and handle the specified actions. Errors are automatically updated to reflect current requirements.
 
-```swift
-import SeamSDK
-import Combine
-
-private var permissionCancellable: AnyCancellable?
-```
-
 ## Monitoring Permission Errors
 
-Use Combine to watch the published credentials array and handle permission-related errors:
-
 {% tabs %}
 {% tab title="iOS Swift" %}
 
+Use Combine to watch the published credentials array and handle permission-related errors:
+
+
 ```swift
 func startMonitoringPermissionErrors() {
-    permissionCancellable = SeamSDKManager.shared.$credentials
+    permissionCancellable = Seam.shared.$credentials
         .map { credentials in
             credentials.flatMap { credential in
                 credential.errors.compactMap { error in
@@ -37,7 +31,7 @@ func startMonitoringPermissionErrors() {
 {% endtabs %}
 
 
-The SDK automatically clears resolved permission errors once the required permission is granted, reflecting the updated credential state.
+The Seam SDK automatically clears resolved permission errors once the required permission is granted, reflecting the updated credential state.
 
 ## Handling Permission Actions
 

docs/capability-guides/mobile-access/mobile-device-sdks/initializing-the-seam-mobile-sdk.md

@@ -37,7 +37,7 @@ dependencies {
 
 {% tab title="iOS Swift" %}
 You can install SeamSDK via CocoaPods or Swift Package Manager (SPM).  
-SeamSDK supports per-lock-provider integration granularity--include only the modules you need to keep your app footprint minimal.
+SeamSDK supports per-lock-provider integration granularity--include only the modules you need to minimize your app's footprint.
 
 {% code title="Podfile" %}
 ```ruby
@@ -86,7 +86,7 @@ See the [device or system integration guide](../../../device-and-system-integrat
 
 ### iOS Requirement
 
-To prevent Apple Wallet from appearing while scanning for Bluetooth low energy (BLE) or similar locks, request the `com.apple.developer.passkit.pass-presentation-suppression` entitlement for your app from the Apple Developer portal.
+While not required, you can optionally request the `com.apple.developer.passkit.pass-presentation-suppression` entitlement from the Apple Developer portal. This entitlement prevents Apple Wallet from appearing when scanning for Bluetooth low energy (BLE) or similar locks, improving the unlock experience.
 
 ***
 
@@ -206,7 +206,7 @@ $token = $client_session->token;
 ## 4. Initialize the Mobile SDK with the Client Session Token
 
 
-Use the client session token you generated earlier to bootstrap the Seam SDK on the device. Under the hood, this will set up credential synchronization and start a background sync loop to keep permissions up to date.
+Use the client session token you generated earlier to bootstrap the Seam SDK on the device. Under the hood, this will set up credential synchronization and start a background sync loop to keep credentials up to date.
 
 
 ### Initialization and Error Handling
@@ -247,16 +247,13 @@ import SeamSDK
 Task {
     do {
         // Bootstrap the SDK with the CST from your login flow
-        try SeamSDKManager.initialize(clientSessionToken: token)
+        try Seam.initialize(clientSessionToken: token)
         // Start credential sync and background polling
-        try await SeamSDKManager.shared.activate()
+        try await Seam.shared.activate()
         print("Seam SDK is now active")
-    } catch let error as SeamSDKV2Error {
-        // Handle SDK-specific initialization errors (invalid token, workspace issues)
+    } catch let error as SeamError {
+        // Handle SDK-specific initialization errors (invalid token, etc)
         showAlert(title: "Initialization Failed", message: error.localizedDescription)
-    } catch {
-        // Handle any other errors (network, unexpected)
-        showAlert(title: "Unexpected Error", message: error.localizedDescription)
     }
 }
 ```
@@ -275,7 +272,7 @@ import Combine
 private var credentialErrorsCancellable: AnyCancellable?
 
 func startMonitoringCredentialErrors() {
-    credentialErrorsCancellable = SeamSDKManager.shared.$credentials
+    credentialErrorsCancellable = Seam.shared.$credentials
         .sink { credentials in
             for credential in credentials where !credential.errors.isEmpty {
                 print("Errors for \(credential.displayName):", credential.errors)
@@ -286,15 +283,17 @@ func startMonitoringCredentialErrors() {
 
 #### Credential Error Types
 
-- `awaitingLocalCredential`: Credential is being prepared locally.
-- `expired`: Credential has expired and cannot be used.
-- `userInteractionRequired(action)`: Additional user interaction required; check the `action` for specifics.
-- `unknown`: An unspecified error occurred.
+- `awaitingLocalCredential`: The system is waiting for a local credential to become available.
+- `expired`: The credential has expired and is no longer valid.
+- `userInteractionRequired(action)`: User interaction is required to resolve the credential issue; check the action for specifics.
+- `contactSeamSupport`: Configuration error requiring developer attention.
+- `unsupportedDevice`: The current device is not supported.
+- `unknown`: An unclassified or unexpected credential error occurred.
 
 #### Possible `userInteractionRequired` Actions
 
-- `completeOtpAuthorization(otpUrl:)`: User must complete OTP authorization.
-- `enableInternet`: User must enable internet connectivity.
-- `enableBluetooth`: User must enable Bluetooth.
-- `grantBluetoothPermission`: User must grant Bluetooth permission.
-- `appRestartRequired`: User must restart the app.
+- `completeOtpAuthorization(otpUrl:)`: The user must complete OTP authorization via the provided URL.
+- `enableInternet`: The user must enable internet connectivity.
+- `enableBluetooth`: The user must enable Bluetooth on the device.
+- `grantBluetoothPermission`: The user must grant Bluetooth permission to the app.
+- `appRestartRequired`: The user must restart the app to resolve the issue.

docs/capability-guides/mobile-access/mobile-device-sdks/using-unlock-with-tap.md

@@ -5,30 +5,30 @@ description: >-
 
 # Unlocking
 
-Unlocking with SeamSDK uses proximity to communicate credentials to door readers. When a user initiates an unlock, the SDK performs scanning, error handling, and unlock events via `SeamSDKManager.shared.unlock(using:)`.
+Unlocking with SeamSDK uses proximity to communicate credentials to door readers. When a user initiates an unlock, the SDK performs scanning, error handling, and unlock events via `Seam.shared.unlock(using:)`.
 
 Using this process involves the following steps:
 
 1. Retrieve available mobile credentials.  
-2. Monitor for permission or credential errors unhandled errors will be thrown as `credentialErrors([SeamSDKCredentialError])`  
+2. Monitor for permission or credential errors unhandled errors will be thrown as `credentialErrors([SeamCredentialError])`  
 3. Perform the unlock operation.  
 4. Handle unlock status events.  
-5. Cancel the unlock operation when needed.
+5. Cancel the unlock operation if needed.
 
 ***
 
 ## 1. Retrieve Mobile Credentials
 
-Access the current credentials via the published `credentials` array on `SeamSDKManager.shared`:
+Access the current credentials via the published `credentials` array on `Seam.shared`:
 
 {% tabs %}
 {% tab title="iOS Swift" %}
 ```swift
 // Access credentials
-let credentials = SeamSDKManager.shared.credentials
+let credentials = Seam.shared.credentials
 
 // Observe updates with Combine
-let credentialsSubscription = SeamSDKManager.shared.$credentials
+let credentialsSubscription = Seam.shared.$credentials
     .sink { creds in
         // Update UI with new credentials array
     }
@@ -43,7 +43,7 @@ Permission or setup issues appear in each credential’s `errors` property. Obse
 {% tabs %}
 {% tab title="iOS Swift" %}
 ```swift
-let errorSubscription = SeamSDKManager.shared.$credentials
+let errorSubscription = Seam.shared.$credentials
     .flatMap { creds in creds.publisher }
     .map { $0.errors }
     .sink { errors in
@@ -53,30 +53,31 @@ let errorSubscription = SeamSDKManager.shared.$credentials
 {% endtab %}
 {% endtabs %}
 
-> **Note:** The `.errors` array on credentials represents per-credential issues though some issues may be repeated across several credentials (e.g. bluetooth requirements). SDK- or credential-level errors (such as invalid token or expired credential) are thrown directly by methods like `unlock(using:)` as `SeamSDKV2Error` or `SeamSDKCredentialError` and must be handled via `do/catch`.
+> **Note:** The `.errors` array on credentials represents per-credential issues though some issues may be repeated across several credentials (e.g. bluetooth requirements). Seam SDK- or credential-level errors (such as invalid token or expired credential) are thrown directly by `unlock(using:)` as `SeamError` and must be handled via `do/catch`.
 
 ## 3. Perform Unlock Operation
 
-The call to `SeamSDKManager.shared.unlock(using:)` may throw:
-- `SeamSDKV2Error`: for SDK-level issues (e.g., invalid token, uninitialized SDK).
-- `SeamSDKCredentialError`: for credential-specific issues (e.g., expired credential, device not eligible).
+The call to `Seam.shared.unlock(using:)` may throw:
+- `SeamError`: for SDK-level issues (e.g., invalid token, uninitialized SDK).
+- `SeamCredentialError`: for credential-specific issues (e.g., expired credential, device not eligible).
 Ensure you wrap the call in `do/catch` to handle these errors.
 
 Use Async/Await or Combine to initiate an unlock with a selected credential:
 
 {% tabs %}
 {% tab title="iOS Swift" %}
 ```swift
-let credentialID = credentials.first!.id
+let credentialId = credentials.first!.id
 
 // Async/Await example
 Task {
     do {
-        for try await event in SeamSDKManager.shared.unlock(using: credentialID) {
+        for try await event in try Seam.shared.unlock(using: credentialId).values {
             switch event {
             case .grantedAccess:
                 // The lock granted access—show a success indicator.
             default:
+                print("Unlock event: \(event)")
                 // Access wasn't granted, inform the user and offer retry.
             }
         }
@@ -88,26 +89,25 @@ Task {
 
 // Combine example
 do {
-    let unlockPublisher = try SeamSDKManager.shared.unlock(using: credentialID)
+    let unlockPublisher = try Seam.shared.unlock(using: credentialId)
     let unlockSubscription = unlockPublisher.sink(
-        receiveCompletion: { completion in
-            if case .failure(let error) = completion {
-                // Show unlock error UI, e.g., "Unlock failed: \(error)"
-            }
+        receiveCompletion: { _ in
+            // Unlock completed.
         },
         receiveValue: { event in
             switch event {
             case .grantedAccess:
                 // The lock granted access—show a success indicator.
             default:
                 // Access wasn't granted, inform the user and offer retry.
+                print("Unlock event: \(event)")
             }
         }
     )
-    // Retain `unlockSubscription` as needed
+    // Retain `unlockSubscription`; discarding it will cancel the unlock attempt.
 } catch {
     // Handle unlock initialization error
-    print("Unlock initialization error: \(error)")
+    print("Unlock error: \(error)")
 }
 ```
 {% endtab %}
@@ -119,8 +119,6 @@ Handle each `SeamUnlockEvent` to update your UI and logic. Available events:
 
 - **launched**  
   Unlock operation has started.
-- **connected**  
-  Connection to the lock hardware was successful.
 - **grantedAccess**  
   Access was granted by the lock.
 - **timedOut**  
@@ -136,12 +134,10 @@ Async/Await example:
 ```swift
 Task {
     do {
-        for try await event in SeamSDKManager.shared.unlock(using: credentialID) {
+        for try await event in Seam.shared.unlock(using: credentialID) {
             switch event {
             case .launched:
                 // Show scanning indicator
-            case .connected:
-                // Show connected indicator
             case .grantedAccess:
                 // Show access granted
             case .timedOut:
@@ -160,28 +156,24 @@ Combine example:
 
 ```swift
 do {
-    let unlockPublisher = try SeamSDKManager.shared.unlock(using: credentialID)
+    let unlockPublisher = try Seam.shared.unlock(using: credentialID)
     let unlockSubscription = unlockPublisher
         .receive(on: RunLoop.main)
         .sink(
-            receiveCompletion: { completion in
-                if case .failure(let error) = completion {
-                    // Show unlock error UI, e.g., "Unlock failed: \(error)"
-                }
+            receiveCompletion: { _ in
+                // unlock completed.
             },
             receiveValue: { event in
                 switch event {
+                case .launched:
+                    // Show scanning indicator.
                 case .grantedAccess:
                     // Show success indicator.
-                case .retry:
-                    // Retry scanning or credential presentation.
-                case .deniedAccess:
-                    // Access denied—inform the user.
                 case .timedOut:
                     // Operation timed out—offer retry.
                 case .connectionFailed(let debugDescription):
                     // Show debugDescription details.
-                }
+                }           
             }
         )
     // Retain `unlockSubscription` as a property and cancel when appropriate (e.g., in deinit or viewWillDisappear).