@protontech/drive-sdk 0.0.13 → 0.1.1

package/src/protonDriveClient.ts

@@ -24,8 +24,6 @@ import {
     ThumbnailType,
     ThumbnailResult,
     SDKEvent,
-    DeviceEventCallback,
-    NodeEventCallback,
 } from './interface';
 import { DriveCrypto, SessionKey } from './crypto';
 import { DriveAPIService } from './internal/apiService';
@@ -34,17 +32,25 @@ import { initNodesModule } from './internal/nodes';
 import { initSharingModule } from './internal/sharing';
 import { initDownloadModule } from './internal/download';
 import { initUploadModule } from './internal/upload';
-import { DriveEventsService } from './internal/events';
+import { DriveEventsService, DriveListener } from './internal/events';
 import { SDKEvents } from './internal/sdkEvents';
 import { getConfig } from './config';
-import { getUid, getUids, convertInternalNodePromise, convertInternalNodeIterator, convertInternalMissingNodeIterator, convertInternalNode } from './transformers';
+import {
+    getUid,
+    getUids,
+    convertInternalNodePromise,
+    convertInternalNodeIterator,
+    convertInternalMissingNodeIterator,
+    convertInternalNode,
+} from './transformers';
 import { Telemetry } from './telemetry';
 import { initDevicesModule } from './internal/devices';
-import { makeNodeUid, splitNodeUid } from './internal/uids';
+import { makeNodeUid } from './internal/uids';
+import { EventSubscription } from './internal/events/interface';
 
 /**
  * ProtonDriveClient is the main interface for the ProtonDrive SDK.
- * 
+ *
  * The client provides high-level operations for managing nodes, sharing,
  * and downloading/uploading files. It is the main entry point for using
  * the ProtonDrive SDK.
@@ -63,9 +69,9 @@ export class ProtonDriveClient {
     public experimental: {
         /**
          * Experimental feature to return the URL of the node.
-         * 
+         *
          * Use it when you want to open the node in the ProtonDrive web app.
-         * 
+         *
          * It has hardcoded URLs to open in production client only.
          */
         getNodeUrl: (nodeUid: NodeOrUid) => Promise<string>;
@@ -86,6 +92,7 @@ export class ProtonDriveClient {
         srpModule,
         config,
         telemetry,
+        latestEventIdProvider,
     }: ProtonDriveClientContructorParameters) {
         if (!telemetry) {
             telemetry = new Telemetry();
@@ -95,14 +102,70 @@ export class ProtonDriveClient {
         const fullConfig = getConfig(config);
         this.sdkEvents = new SDKEvents(telemetry);
         const cryptoModule = new DriveCrypto(openPGPCryptoModule, srpModule);
-        const apiService = new DriveAPIService(telemetry, this.sdkEvents, httpClient, fullConfig.baseUrl, fullConfig.language);
-        this.events = new DriveEventsService(telemetry, apiService, entitiesCache);
+        const apiService = new DriveAPIService(
+            telemetry,
+            this.sdkEvents,
+            httpClient,
+            fullConfig.baseUrl,
+            fullConfig.language,
+        );
         this.shares = initSharesModule(telemetry, apiService, entitiesCache, cryptoCache, account, cryptoModule);
-        this.nodes = initNodesModule(telemetry, apiService, entitiesCache, cryptoCache, account, cryptoModule, this.events, this.shares);
-        this.sharing = initSharingModule(telemetry, apiService, entitiesCache, account, cryptoModule, this.events, this.shares, this.nodes.access, this.nodes.events);
-        this.download = initDownloadModule(telemetry, apiService, cryptoModule, account, this.shares, this.nodes.access, this.nodes.revisions);
-        this.upload = initUploadModule(telemetry, apiService, cryptoModule, this.shares, this.nodes.access, this.nodes.events);
-        this.devices = initDevicesModule(telemetry, apiService, cryptoModule, this.shares, this.nodes.access, this.nodes.management);
+        this.nodes = initNodesModule(
+            telemetry,
+            apiService,
+            entitiesCache,
+            cryptoCache,
+            account,
+            cryptoModule,
+            this.shares,
+        );
+        this.sharing = initSharingModule(
+            telemetry,
+            apiService,
+            entitiesCache,
+            account,
+            cryptoModule,
+            this.shares,
+            this.nodes.access,
+        );
+        this.download = initDownloadModule(
+            telemetry,
+            apiService,
+            cryptoModule,
+            account,
+            this.shares,
+            this.nodes.access,
+            this.nodes.revisions,
+        );
+        this.upload = initUploadModule(
+            telemetry,
+            apiService,
+            cryptoModule,
+            this.shares,
+            this.nodes.access,
+            fullConfig.clientUid,
+        );
+        this.devices = initDevicesModule(
+            telemetry,
+            apiService,
+            cryptoModule,
+            this.shares,
+            this.nodes.access,
+            this.nodes.management,
+        );
+        // These are used to keep the internal cache up to date
+        const cacheEventListeners: DriveListener[] = [
+            this.nodes.eventHandler.updateNodesCacheOnEvent,
+            this.sharing.eventHandler.handleDriveEvent,
+        ];
+        this.events = new DriveEventsService(
+            telemetry,
+            apiService,
+            this.shares,
+            cacheEventListeners,
+            latestEventIdProvider,
+        );
+
         this.experimental = {
             getNodeUrl: async (nodeUid: NodeOrUid) => {
                 this.logger.debug(`Getting node URL for ${getUid(nodeUid)}`);
@@ -116,12 +179,12 @@ export class ProtonDriveClient {
                 }
                 return keys.contentKeyPacketSessionKey;
             },
-        }
+        };
     }
 
     /**
      * Subscribes to the general SDK events.
-     * 
+     *
      * This is not connected to the remote data updates. For that, use
      * and see `subscribeToRemoteDataUpdates`.
      *
@@ -135,197 +198,39 @@ export class ProtonDriveClient {
     }
 
     /**
-     * Subscribes to the remote data updates.
-     * 
-     * By default, SDK doesn't subscribe to remote data updates. If you
-     * cache the data locally, you need to call this method so the SDK
-     * keeps the local cache in sync with the remote data.
-     * 
-     * Only one instance of the SDK should subscribe to remote data updates.
+     * Subscribes to the remote data updates for all files and folders in a
+     * tree.
      *
-     * Once subscribed, the SDK will poll for events for core user events and
-     * for own data at minimum. Updates to nodes from other users are polled
-     * with lower frequency depending on the number of subscriptions, and only
-     * after accessing them for the first time via `iterateSharedNodesWithMe`.
-     */
-    async subscribeToRemoteDataUpdates(): Promise<void> {
-        this.logger.debug('Subscribing to remote data updates');
-        await this.events.subscribeToRemoteDataUpdates();
-
-        const { volumeId } = await this.shares.getMyFilesIDs();
-        await this.events.listenToVolume(volumeId, true);
-    }
-
-    /**
-     * Subscribe to updates of the devices.
-     * 
-     * Clients should subscribe to this before beginning to list devices
-     * to ensure that updates are reflected once a device is in the cache.
-     * Subscribing before listing is also required to ensure that devices
-     * that are created during the listing will be recognized.
-     * 
-     * ```typescript
-     * const unsubscribe = sdk.subscribeToDevices((event) => {
-     *     if (event.type === 'update') {
-     *         // Update the device in the UI
-     *     } else if (event.type === 'remove') {
-     *         // Remove the device from the UI
-     *     }
-     * });
-     *
-     * const devices = await Array.fromAsync(sdk.iterateDevices());
-     * // Render the devices in the UI
-     * 
-     * // Unsubscribe from the updates when the component is unmounted
-     * unsubscribe();
-     * ```
+     * In order to keep local data up to date, the client must call this method
+     * to receive events on update and to keep the SDK cache in sync.
      *
-     * @param callback - Callback to be called when the event is emitted.
-     * @returns Callback to unsubscribe from the event.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    subscribeToDevices(callback: DeviceEventCallback): () => void {
-        this.logger.debug('Subscribing to devices');
-        throw new Error('Method not implemented');
-    }
-
-    /**
-     * Subscribe to updates of the children of the given parent node.
-     * 
-     * Clients should subscribe to this before beginning to list children
-     * to ensure that updates are reflected once a node is in the cache.
-     * Subscribing before listing is also required to ensure that nodes 
-     * that are created during the listing will be recognized.
-     * 
-     * ```typescript
-     * const unsubscribe = sdk.subscribeToChildren(parentNodeUid, (event) => {
-     *     if (event.type === 'update') {
-     *         // Update the node in the UI
-     *     } else if (event.type === 'remove') {
-     *         // Remove the node from the UI
-     *     }
-     * });
-     *
-     * const nodes = await Array.fromAsync(sdk.iterateChildren(parentNodeUid));
-     * // Render the nodes in the UI
-     * 
-     * // Unsubscribe from the updates when the component is unmounted
-     * unsubscribe();
-     * ```
+     * The `treeEventScopeId` can be obtained from node properties.
      *
-     * @param parentNodeUid - Node entity or its UID string.
-     * @param callback - Callback to be called when the event is emitted.
-     * @returns Callback to unsubscribe from the event.
+     * Only one instance of the SDK should subscribe to updates.
      */
-    subscribeToFolder(parentNodeUid: NodeOrUid, callback: NodeEventCallback): () => void {
-        this.logger.debug(`Subscribing to children of ${getUid(parentNodeUid)}`);
-        return this.nodes.events.subscribeToChildren(getUid(parentNodeUid), callback);
+    async subscribeToTreeEvents(treeEventScopeId: string, callback: DriveListener): Promise<EventSubscription> {
+        this.logger.debug('Subscribing to node updates');
+        return this.events.subscribeToTreeEvents(treeEventScopeId, callback);
     }
 
     /**
-     * Subscribe to updates of the trashed nodes.
-     * 
-     * Clients should subscribe to this before beginning to list trashed
-     * nodes to ensure that updates are reflected once a node is in the cache.
-     * Subscribing before listing is also required to ensure that nodes
-     * that are trashed during the listing will be recognized.
-     * 
-     * ```typescript
-     * const unsubscribe = sdk.subscribeToTrashedNodes((event) => {
-     *     if (event.type === 'update') {
-     *         // Update the node in the UI
-     *     } else if (event.type === 'remove') {
-     *         // Remove the node from the UI
-     *     }
-     * });
-     *
-     * const nodes = await Array.fromAsync(sdk.iterateTrashedNodes());
-     * // Render the nodes in the UI
-     * 
-     * // Unsubscribe from the updates when the component is unmounted
-     * unsubscribe();
-     * ```
+     * Subscribes to sharing updates.
      *
-     * @param callback - Callback to be called when the event is emitted.
-     * @returns Callback to unsubscribe from the event.
-     */
-    subscribeToTrashedNodes(callback: NodeEventCallback): () => void {
-        this.logger.debug('Subscribing to trashed nodes');
-        return this.nodes.events.subscribeToTrashedNodes(callback);
-    }
-
-    /**
-     * Subscribe to updates of the nodes shared by the user.
-     * 
-     * Clients should subscribe to this before beginning to list shared
-     * nodes to ensure that updates are reflected once a node is in the cache.
-     * Subscribing before listing is also required to ensure that nodes
-     * that are shared during the listing will be recognized.
-     * 
-     * ```typescript
-     * const unsubscribe = sdk.subscribeToSharedNodesByMe((event) => {
-     *     if (event.type === 'update') {
-     *         // Update the node in the UI
-     *     } else if (event.type === 'remove') {
-     *         // Remove the node from the UI
-     *     }
-     * });
-     * 
-     * const nodes = await Array.fromAsync(sdk.iterateSharedNodes());
-     * // Render the nodes in the UI
-     * 
-     * // Unsubscribe from the updates when the component is unmounted
-     * unsubscribe();
-     * ```
-     * 
-     * @param callback - Callback to be called when the event is emitted.
-     * @returns Callback to unsubscribe from the event.
-     */
-    subscribeToSharedNodesByMe(callback: NodeEventCallback): () => void {
-        this.logger.debug('Subscribing to shared nodes by me');
-        return this.sharing.events.subscribeToSharedNodesByMe(callback);
-    }
-
-    /**
-     * Subscribe to updates of the nodes shared with the user.
-     * 
-     * Clients should subscribe to this before beginning to list shared
-     * nodes to ensure that updates are reflected once a node is in the cache.
-     * Subscribing before listing is also required to ensure that nodes
-     * that are shared during the listing will be recognized.
-     * 
-     * ```typescript
-     * const unsubscribe = sdk.subscribeToSharedNodesWithMe((event) => {
-     *     if (event.type === 'update') {
-     *         // Update the node in the UI
-     *     } else if (event.type === 'remove') {
-     *         // Remove the node from the UI
-     *     }
-     * });
-     * 
-     * const nodes = await Array.fromAsync(sdk.iterateSharedNodesWithMe());
-     * // Render the nodes in the UI
-     * 
-     * // Unsubscribe from the updates when the component is unmounted
-     * unsubscribe();
-     * ```
-     * 
-     * @param callback - Callback to be called when the event is emitted.
-     * @returns Callback to unsubscribe from the event.
+     * Only one instance of the SDK should subscribe to updates.
      */
-    subscribeToSharedNodesWithMe(callback: NodeEventCallback): () => void {
-        this.logger.debug('Subscribing to shared nodes with me');
-        return this.sharing.events.subscribeToSharedNodesWithMe(callback);
+    async subscribeToDriveEvents(callback: DriveListener): Promise<EventSubscription> {
+        this.logger.debug('Subscribing to core updates');
+        return this.events.subscribeToCoreEvents(callback);
     }
 
     /**
      * Provides the node UID for the given raw share and node IDs.
-     * 
+     *
      * This is required only for the internal implementation to provide
      * backward compatibility with the old Drive web setup.
-     * 
+     *
      * If you are having volume ID, use `generateNodeUid` instead.
-     * 
+     *
      * @deprecated This method is not part of the public API.
      * @param shareId - Context share of the node.
      * @param nodeId - Node/link ID (not UID).
@@ -347,48 +252,44 @@ export class ProtonDriveClient {
 
     /**
      * Iterates the children of the given parent node.
-     * 
-     * The output is not sorted and the order of the children is not guaranteed.
      *
-     * You can listen to updates via `subscribeToChildren`.
+     * The output is not sorted and the order of the children is not guaranteed.
      *
      * @param parentNodeUid - Node entity or its UID string.
      * @param signal - Signal to abort the operation.
      * @returns An async generator of the children of the given parent node.
      */
-    async* iterateFolderChildren(parentNodeUid: NodeOrUid, signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+    async *iterateFolderChildren(parentNodeUid: NodeOrUid, signal?: AbortSignal): AsyncGenerator<MaybeNode> {
         this.logger.info(`Iterating children of ${getUid(parentNodeUid)}`);
         yield* convertInternalNodeIterator(this.nodes.access.iterateFolderChildren(getUid(parentNodeUid), signal));
     }
 
     /**
      * Iterates the trashed nodes.
-     * 
+     *
      * The list of trashed nodes is not cached and is fetched from the server
      * on each call. The node data itself are served from cached if available.
-     * 
-     * The output is not sorted and the order of the trashed nodes is not guaranteed.
      *
-     * You can listen to updates via `subscribeToTrashedNodes`.
+     * The output is not sorted and the order of the trashed nodes is not guaranteed.
      *
      * @param signal - Signal to abort the operation.
      * @returns An async generator of the trashed nodes.
      */
-    async* iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+    async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
         this.logger.info('Iterating trashed nodes');
         yield* convertInternalNodeIterator(this.nodes.access.iterateTrashedNodes(signal));
     }
 
     /**
      * Iterates the nodes by their UIDs.
-     * 
+     *
      * The output is not sorted and the order of the nodes is not guaranteed.
      *
      * @param nodeUids - List of node entities or their UIDs.
      * @param signal - Signal to abort the operation.
      * @returns An async generator of the nodes.
      */
-    async* iterateNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<MaybeMissingNode> {
+    async *iterateNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<MaybeMissingNode> {
         this.logger.info(`Iterating ${nodeUids.length} nodes`);
         yield* convertInternalMissingNodeIterator(this.nodes.access.iterateNodes(getUids(nodeUids), signal));
     }
@@ -419,13 +320,13 @@ export class ProtonDriveClient {
 
     /**
      * Move the nodes to a new parent node.
-     * 
+     *
      * The operation is performed node by node and the results are yielded
      * as they are available. Order of the results is not guaranteed.
-     * 
+     *
      * If one of the nodes fails to move, the operation continues with the
      * rest of the nodes. Use `NodeResult` to check the status of the action.
-     * 
+     *
      * Only move withing the same section is supported at this moment.
      * That means that the new parent node must be in the same section
      * as the nodes being moved. E.g., moving from My files to Shared with
@@ -436,17 +337,21 @@ export class ProtonDriveClient {
      * @param signal - Signal to abort the operation.
      * @returns An async generator of the results of the move operation
      */
-    async* moveNodes(nodeUids: NodeOrUid[], newParentNodeUid: NodeOrUid, signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    async *moveNodes(
+        nodeUids: NodeOrUid[],
+        newParentNodeUid: NodeOrUid,
+        signal?: AbortSignal,
+    ): AsyncGenerator<NodeResult> {
         this.logger.info(`Moving ${nodeUids.length} nodes to ${newParentNodeUid}`);
         yield* this.nodes.management.moveNodes(getUids(nodeUids), getUid(newParentNodeUid), signal);
     }
 
     /**
      * Trash the nodes.
-     * 
+     *
      * The operation is performed in batches and the results are yielded
      * as they are available. Order of the results is not guaranteed.
-     * 
+     *
      * If one of the nodes fails to trash, the operation continues with the
      * rest of the nodes. Use `NodeResult` to check the status of the action.
      *
@@ -454,17 +359,17 @@ export class ProtonDriveClient {
      * @param signal - Signal to abort the operation.
      * @returns An async generator of the results of the trash operation
      */
-    async* trashNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    async *trashNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         this.logger.info(`Trashing ${nodeUids.length} nodes`);
         yield* this.nodes.management.trashNodes(getUids(nodeUids), signal);
     }
 
     /**
      * Restore the nodes from the trash to their original place.
-     * 
+     *
      * The operation is performed in batches and the results are yielded
      * as they are available. Order of the results is not guaranteed.
-     * 
+     *
      * If one of the nodes fails to restore, the operation continues with the
      * rest of the nodes. Use `NodeResult` to check the status of the action.
      *
@@ -472,17 +377,17 @@ export class ProtonDriveClient {
      * @param signal - Signal to abort the operation.
      * @returns An async generator of the results of the restore operation
      */
-    async* restoreNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    async *restoreNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         this.logger.info(`Restoring ${nodeUids.length} nodes`);
         yield* this.nodes.management.restoreNodes(getUids(nodeUids), signal);
     }
 
     /**
      * Delete the nodes permanently.
-     * 
+     *
      * The operation is performed in batches and the results are yielded
      * as they are available. Order of the results is not guaranteed.
-     * 
+     *
      * If one of the nodes fails to delete, the operation continues with the
      * rest of the nodes. Use `NodeResult` to check the status of the action.
      *
@@ -490,7 +395,7 @@ export class ProtonDriveClient {
      * @param signal - Signal to abort the operation.
      * @returns An async generator of the results of the delete operation
      */
-    async* deleteNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    async *deleteNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         this.logger.info(`Deleting ${nodeUids.length} nodes`);
         yield* this.nodes.management.deleteNodes(getUids(nodeUids), signal);
     }
@@ -502,7 +407,7 @@ export class ProtonDriveClient {
 
     /**
      * Create a new folder.
-     * 
+     *
      * The folder is created in the given parent node.
      *
      * @param parentNodeUid - Node entity or its UID string of the parent folder.
@@ -515,15 +420,17 @@ export class ProtonDriveClient {
      */
     async createFolder(parentNodeUid: NodeOrUid, name: string, modificationTime?: Date): Promise<MaybeNode> {
         this.logger.info(`Creating folder in ${getUid(parentNodeUid)}`);
-        return convertInternalNodePromise(this.nodes.management.createFolder(getUid(parentNodeUid), name, modificationTime));
+        return convertInternalNodePromise(
+            this.nodes.management.createFolder(getUid(parentNodeUid), name, modificationTime),
+        );
     }
 
     /**
      * Iterates the revisions of given node.
-     * 
+     *
      * The list of node revisions is not cached and is fetched and decrypted
      * from the server on each call.
-     * 
+     *
      * The output is sorted by the revision date in descending order (newest
      * first).
      *
@@ -531,7 +438,7 @@ export class ProtonDriveClient {
      * @param signal - Signal to abort the operation.
      * @returns An async generator of the node revisions.
      */
-    async* iterateRevisions(nodeUid: NodeOrUid, signal?: AbortSignal): AsyncGenerator<Revision> {
+    async *iterateRevisions(nodeUid: NodeOrUid, signal?: AbortSignal): AsyncGenerator<Revision> {
         this.logger.info(`Iterating revisions of ${getUid(nodeUid)}`);
         yield* this.nodes.revisions.iterateRevisions(getUid(nodeUid), signal);
     }
@@ -565,13 +472,11 @@ export class ProtonDriveClient {
      * Iterates the nodes shared by the user.
      *
      * The output is not sorted and the order of the shared nodes is not guaranteed.
-     * 
-     * You can listen to updates via `subscribeToSharedNodesByMe`.
      *
      * @param signal - Signal to abort the operation.
      * @returns An async generator of the shared nodes.
      */
-    async* iterateSharedNodes(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+    async *iterateSharedNodes(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
         this.logger.info('Iterating shared nodes by me');
         yield* convertInternalNodeIterator(this.sharing.access.iterateSharedNodes(signal));
     }
@@ -580,28 +485,19 @@ export class ProtonDriveClient {
      * Iterates the nodes shared with the user.
      *
      * The output is not sorted and the order of the shared nodes is not guaranteed.
-     * 
-     * At the end of the iteration, if `subscribeToRemoteDataUpdates` was called,
-     * the SDK will listen to updates for the shared nodes to keep the local cache
-     * in sync with the remote data.
-     * 
-     * You can listen to updates via `subscribeToSharedNodesWithMe`.
+     *
+     * Clients can subscribe to drive events in order to receive a
+     * `SharedWithMeUpdated` event when there are changes to the user's
+     * access to shared nodes.
      *
      * @param signal - Signal to abort the operation.
      * @returns An async generator of the shared nodes.
      */
-    async* iterateSharedNodesWithMe(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+    async *iterateSharedNodesWithMe(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
         this.logger.info('Iterating shared nodes with me');
 
-        const uniqueVolumeIds = new Set<string>();
         for await (const node of this.sharing.access.iterateSharedNodesWithMe(signal)) {
             yield convertInternalNode(node);
-            const { volumeId } = splitNodeUid(node.uid);
-            uniqueVolumeIds.add(volumeId);
-        }
-
-        for (const volumeId of uniqueVolumeIds) {
-            await this.events.listenToVolume(volumeId, false);
         }
     }
 
@@ -623,7 +519,7 @@ export class ProtonDriveClient {
      * @param signal - Signal to abort the operation.
      * @returns An async generator of the invitations.
      */
-    async* iterateInvitations(signal?: AbortSignal): AsyncGenerator<ProtonInvitationWithNode> {
+    async *iterateInvitations(signal?: AbortSignal): AsyncGenerator<ProtonInvitationWithNode> {
         this.logger.info('Iterating invitations');
         yield* this.sharing.access.iterateInvitations(signal);
     }
@@ -656,7 +552,7 @@ export class ProtonDriveClient {
      * @param signal - Signal to abort the operation.
      * @returns An async generator of the shared bookmarks.
      */
-    async* iterateBookmarks(signal?: AbortSignal): AsyncGenerator<MaybeBookmark> {
+    async *iterateBookmarks(signal?: AbortSignal): AsyncGenerator<MaybeBookmark> {
         this.logger.info('Iterating shared bookmarks');
         yield* this.sharing.access.iterateBookmarks(signal);
     }
@@ -673,7 +569,7 @@ export class ProtonDriveClient {
 
     /**
      * Get sharing info of the node.
-     * 
+     *
      * The sharing info contains the list of invitations, members,
      * public link and permission for each.
      *
@@ -690,7 +586,7 @@ export class ProtonDriveClient {
 
     /**
      * Share or update sharing of the node.
-     * 
+     *
      * If the node is already shared, the sharing settings are updated.
      * If the member is already present but with different role, the role
      * is updated. If the sharing settings is identical, the sharing info
@@ -722,46 +618,49 @@ export class ProtonDriveClient {
         return this.sharing.management.unshareNode(getUid(nodeUid), settings);
     }
 
-    async resendInvitation(nodeUid: NodeOrUid, invitationUid: ProtonInvitationOrUid | NonProtonInvitationOrUid): Promise<void> {
+    async resendInvitation(
+        nodeUid: NodeOrUid,
+        invitationUid: ProtonInvitationOrUid | NonProtonInvitationOrUid,
+    ): Promise<void> {
         this.logger.info(`Resending invitation ${getUid(invitationUid)}`);
-        return this.sharing.management.resendInvitationEmail(getUid(nodeUid), getUid(invitationUid))
+        return this.sharing.management.resendInvitationEmail(getUid(nodeUid), getUid(invitationUid));
     }
 
     /**
      * Get the file downloader to download the node content of the active
      * revision. For downloading specific revision of the file, use
      * `getFileRevisionDownloader`.
-     * 
+     *
      * The number of ongoing downloads is limited. If the limit is reached,
      * the download is queued and started when the slot is available. It is
      * recommended to not start too many downloads at once to avoid having
      * many open promises.
-     * 
+     *
      * The file downloader is not reusable. If the download is interrupted,
      * a new file downloader must be created.
-     * 
+     *
      * Before download, the authorship of the node should be checked and
      * reported to the user if there is any signature issue, notably on the
      * content author on the revision.
-     * 
+     *
      * Client should not automatically retry the download if it fails. The
      * download should be initiated by the user again. The downloader does
      * automatically retry the download if it fails due to network issues,
-     * or if the server is temporarily unavailable. 
-     * 
+     * or if the server is temporarily unavailable.
+     *
      * Once download is initiated, the download can fail, besides network
      * issues etc., only when there is integrity error. It should be considered
      * a bug and reported to the Drive developers. The SDK provides option
      * to bypass integrity checks, but that should be used only for debugging
      * purposes, not available to the end users.
-     * 
+     *
      * Example usage:
-     * 
+     *
      * ```typescript
      * const downloader = await client.getFileDownloader(nodeUid, signal);
      * const claimedSize = fileDownloader.getClaimedSizeInBytes();
      * const downloadController = fileDownloader.writeToStream(stream, (downloadedBytes) => { ... });
-     * 
+     *
      * signalController.abort(); // to cancel
      * downloadController.pause(); // to pause
      * downloadController.resume(); // to resume
@@ -782,15 +681,19 @@ export class ProtonDriveClient {
     }
 
     /**
-    * Iterates the thumbnails of the given nodes.
-    *
-    * The output is not sorted and the order of the nodes is not guaranteed.
-    *
-    * @param nodeUids - List of node entities or their UIDs.
-    * @param thumbnailType - Type of the thumbnail to download.
-    * @returns An async generator of the results of the restore operation
-    */
-    async *iterateThumbnails(nodeUids: NodeOrUid[], thumbnailType?: ThumbnailType, signal?: AbortSignal): AsyncGenerator<ThumbnailResult> {
+     * Iterates the thumbnails of the given nodes.
+     *
+     * The output is not sorted and the order of the nodes is not guaranteed.
+     *
+     * @param nodeUids - List of node entities or their UIDs.
+     * @param thumbnailType - Type of the thumbnail to download.
+     * @returns An async generator of the results of the restore operation
+     */
+    async *iterateThumbnails(
+        nodeUids: NodeOrUid[],
+        thumbnailType?: ThumbnailType,
+        signal?: AbortSignal,
+    ): AsyncGenerator<ThumbnailResult> {
         this.logger.info(`Iterating ${nodeUids.length} thumbnails`);
         yield* this.download.iterateThumbnails(getUids(nodeUids), thumbnailType, signal);
     }
@@ -798,33 +701,38 @@ export class ProtonDriveClient {
     /**
      * Get the file uploader to upload a new file. For uploading a new
      * revision, use `getFileRevisionUploader` instead.
-     * 
+     *
      * The number of ongoing uploads is limited. If the limit is reached,
      * the upload is queued and started when the slot is available. It is
      * recommended to not start too many uploads at once to avoid having
      * many open promises.
-     * 
+     *
      * The file uploader is not reusable. If the upload is interrupted,
      * a new file uploader must be created.
-     * 
+     *
      * Client should not automatically retry the upload if it fails. The
      * upload should be initiated by the user again. The uploader does
      * automatically retry the upload if it fails due to network issues,
      * or if the server is temporarily unavailable.
-     * 
+     *
      * Example usage:
-     * 
+     *
      * ```typescript
      * const uploader = await client.getFileUploader(parentFolderUid, name, metadata, signal);
      * const uploadController = await uploader.writeStream(stream, thumbnails, (uploadedBytes) => { ... });
-     * 
+     *
      * signalController.abort(); // to cancel
      * uploadController.pause(); // to pause
      * uploadController.resume(); // to resume
      * const nodeUid = await uploadController.completion(); // to await completion
      * ```
      */
-    async getFileUploader(parentFolderUid: NodeOrUid, name: string, metadata: UploadMetadata, signal?: AbortSignal): Promise<FileUploader> {
+    async getFileUploader(
+        parentFolderUid: NodeOrUid,
+        name: string,
+        metadata: UploadMetadata,
+        signal?: AbortSignal,
+    ): Promise<FileUploader> {
         this.logger.info(`Getting file uploader for parent ${getUid(parentFolderUid)}`);
         return this.upload.getFileUploader(getUid(parentFolderUid), name, metadata, signal);
     }
@@ -832,28 +740,33 @@ export class ProtonDriveClient {
     /**
      * Same as `getFileUploader`, but for a uploading new revision of the file.
      */
-    async getFileRevisionUploader(nodeUid: NodeOrUid, metadata: UploadMetadata, signal?: AbortSignal): Promise<FileRevisionUploader> {
+    async getFileRevisionUploader(
+        nodeUid: NodeOrUid,
+        metadata: UploadMetadata,
+        signal?: AbortSignal,
+    ): Promise<FileRevisionUploader> {
         this.logger.info(`Getting file revision uploader for ${getUid(nodeUid)}`);
         return this.upload.getFileRevisionUploader(getUid(nodeUid), metadata, signal);
     }
 
     /**
      * Iterates the devices of the user.
-     * 
+     *
      * The output is not sorted and the order of the devices is not guaranteed.
      *
-     * You can listen to updates via `subscribeToDevices`.
+     * New devices can be registered by listening to events in the
+     * event scope of "My Files" and filtering on nodes with null `ParentLinkId`.
      *
      * @returns An async generator of devices.
      */
-    async* iterateDevices(signal?: AbortSignal): AsyncGenerator<Device> {
+    async *iterateDevices(signal?: AbortSignal): AsyncGenerator<Device> {
         this.logger.info('Iterating devices');
         yield* this.devices.iterateDevices(signal);
     }
 
     /**
      * Creates a new device.
-     * 
+     *
      * @param nodeUid - Device entity or its UID string.
      * @returns The created device entity.
      * @throws {@link ValidationError} If the name is empty, too long, or contains a slash.
@@ -865,7 +778,7 @@ export class ProtonDriveClient {
 
     /**
      * Renames a device.
-     * 
+     *
      * @param deviceOrUid - Device entity or its UID string.
      * @returns The updated device entity.
      * @throws {@link ValidationError} If the name is empty, too long, or contains a slash.
@@ -877,7 +790,7 @@ export class ProtonDriveClient {
 
     /**
      * Deletes a device.
-     * 
+     *
      * @param deviceOrUid - Device entity or its UID string.
      */
     async deleteDevice(deviceOrUid: DeviceOrUid): Promise<void> {