@protontech/drive-sdk 0.0.13 → 0.1.0

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,18 @@ 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 { 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 +62,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 +85,7 @@ export class ProtonDriveClient {
         srpModule,
         config,
         telemetry,
+        latestEventIdProvider,
     }: ProtonDriveClientContructorParameters) {
         if (!telemetry) {
             telemetry = new Telemetry();
@@ -96,13 +96,16 @@ export class ProtonDriveClient {
         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);
         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.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, this.nodes.events);
+        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)}`);
@@ -121,7 +124,7 @@ export class ProtonDriveClient {
 
     /**
      * Subscribes to the general SDK events.
-     * 
+     *
      * This is not connected to the remote data updates. For that, use
      * and see `subscribeToRemoteDataUpdates`.
      *
@@ -135,197 +138,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.
+     * Only one instance of the SDK should subscribe to updates.
      */
-    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.
-     */
-    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,10 +192,8 @@ 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.
@@ -363,13 +206,11 @@ export class ProtonDriveClient {
 
     /**
      * 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.
@@ -381,7 +222,7 @@ export class ProtonDriveClient {
 
     /**
      * 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.
@@ -419,13 +260,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
@@ -443,10 +284,10 @@ export class ProtonDriveClient {
 
     /**
      * 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.
      *
@@ -461,10 +302,10 @@ export class ProtonDriveClient {
 
     /**
      * 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.
      *
@@ -479,10 +320,10 @@ export class ProtonDriveClient {
 
     /**
      * 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.
      *
@@ -502,7 +343,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.
@@ -520,10 +361,10 @@ export class ProtonDriveClient {
 
     /**
      * 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).
      *
@@ -565,8 +406,6 @@ 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.
@@ -580,12 +419,10 @@ 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.
@@ -593,15 +430,8 @@ export class ProtonDriveClient {
     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);
         }
     }
 
@@ -673,7 +503,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 +520,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
@@ -731,37 +561,37 @@ export class ProtonDriveClient {
      * 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
@@ -798,26 +628,26 @@ 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
@@ -839,10 +669,11 @@ export class ProtonDriveClient {
 
     /**
      * 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.
      */
@@ -853,7 +684,7 @@ export class ProtonDriveClient {
 
     /**
      * 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 +696,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 +708,7 @@ export class ProtonDriveClient {
 
     /**
      * Deletes a device.
-     * 
+     *
      * @param deviceOrUid - Device entity or its UID string.
      */
     async deleteDevice(deviceOrUid: DeviceOrUid): Promise<void> {

package/src/protonDrivePhotosClient.ts

@@ -1,5 +1,5 @@
 import { DriveAPIService } from './internal/apiService';
-import { ProtonDriveClientContructorParameters } from './interface';
+import { DriveListener, ProtonDriveClientContructorParameters } from './interface';
 import { DriveCrypto } from './crypto';
 import { initSharesModule } from './internal/shares';
 import { initNodesModule } from './internal/nodes';
@@ -32,9 +32,10 @@ export class ProtonDrivePhotosClient {
         const sdkEvents = new SDKEvents(telemetry);
         const cryptoModule = new DriveCrypto(openPGPCryptoModule, srpModule);
         const apiService = new DriveAPIService(telemetry, sdkEvents, httpClient, fullConfig.baseUrl, fullConfig.language);
-        const events = new DriveEventsService(telemetry, apiService, entitiesCache);
         const shares = initSharesModule(telemetry, apiService, entitiesCache, cryptoCache, account, cryptoModule);
-        this.nodes = initNodesModule(telemetry, apiService, entitiesCache, cryptoCache, account, cryptoModule, events, shares);
+        this.nodes = initNodesModule(telemetry, apiService, entitiesCache, cryptoCache, account, cryptoModule, shares);
+        const cacheEventListeners: DriveListener[] = [this.nodes.eventHandler.updateNodesCacheOnEvent];
+        new DriveEventsService(telemetry, apiService, shares, cacheEventListeners);
         this.photos = initPhotosModule(apiService, entitiesCache, this.nodes.access);
     }
 

package/dist/internal/events/cache.d.ts

@@ -1,28 +0,0 @@
-import { ProtonDriveEntitiesCache } from "../../interface";
-interface EventsData {
-    lastEventId: string;
-    pollingIntervalInSeconds: number;
-    isOwnVolume: boolean;
-}
-/**
- * Provides caching for events IDs.
- */
-export declare class EventsCache {
-    private driveCache;
-    /**
-     * Locally cached events data to avoid unnecessary reads from the cache.
-     * Data about last event ID or interval might be accessed often by events
-     * managers.
-     */
-    private events?;
-    constructor(driveCache: ProtonDriveEntitiesCache);
-    setLastEventId(volumeIdOrCore: string, eventsData: EventsData): Promise<void>;
-    getLastEventId(volumeIdOrCore: string): Promise<string | undefined>;
-    getPollingIntervalInSeconds(volumeIdOrCore: string): Promise<number | undefined>;
-    isOwnVolume(volumeIdOrCore: string): Promise<boolean | undefined>;
-    getSubscribedVolumeIds(): Promise<string[]>;
-    private getEvents;
-    private getCachedEvents;
-    private cacheEvents;
-}
-export {};