@protontech/drive-sdk 0.0.10

package/src/internal/nodes/extendedAttributes.test.ts

@@ -0,0 +1,177 @@
+import { getMockLogger } from "../../tests/logger";
+import { FolderExtendedAttributes, FileExtendedAttributesParsed, generateFolderExtendedAttributes, generateFileExtendedAttributes, parseFolderExtendedAttributes, parseFileExtendedAttributes } from './extendedAttributes';
+
+describe('extended attrbiutes', () => {
+    describe('should generate folder attributes', () => {
+        const testCases: [Date | undefined, string | undefined][] = [
+            [undefined, undefined],
+            [new Date(1234567890000), '{"Common":{"ModificationTime":"2009-02-13T23:31:30.000Z"}}'],
+        ];
+        testCases.forEach(([input, expectedAttributes]) => {
+            it(`should generate ${input}`, () => {
+                const output = generateFolderExtendedAttributes(input);
+                expect(output).toBe(expectedAttributes);
+            })
+        });
+    });
+
+    describe('should parse folder attributes', () => {
+        const testCases: [string, FolderExtendedAttributes][] = [
+            ['', {}],
+            ['{}', {}],
+            ['a', {}],
+            [
+                '{"Common": {"ModificationTime": "2009-02-13T23:31:30+0000"}}',
+                {
+                    claimedModificationTime: new Date(1234567890000),
+                },
+            ],
+            [
+                '{"Common": {"ModificationTime": "aa"}}',
+                {},
+            ],
+            [
+                '{"Common": {"ModificationTime": "2009-02-13T23:31:30+0000", "Size": 123}}',
+                {
+                    claimedModificationTime: new Date(1234567890000),
+                },
+            ],
+            [
+                '{"Common": {"Whatever": 123}}',
+                {},
+            ],
+        ];
+        testCases.forEach(([input, expectedAttributes]) => {
+            it(`should parse ${input}`, () => {
+                const output = parseFolderExtendedAttributes(getMockLogger(), input);
+                expect(output).toMatchObject(expectedAttributes);
+            })
+        });
+    });
+
+    describe('should generate file attributes', () => {
+        const testCases: [object, string | undefined][] = [
+            [{}, undefined],
+            [{modificationTime: new Date(1234567890000)}, '{"Common":{"ModificationTime":"2009-02-13T23:31:30.000Z"}}'],
+            [{size: undefined}, undefined],
+            [{size: 0}, '{"Common":{"Size":0}}'],
+            [{size: 1234}, '{"Common":{"Size":1234}}'],
+            [{blockSizes: []}, undefined],
+            [{blockSizes: [4,4,4,2]}, '{"Common":{"BlockSizes":[4,4,4,2]}}'],
+            [{digests: {}}, undefined],
+            [{digests: {sha1: 'abcdef'}}, '{"Common":{"Digests":{"SHA1":"abcdef"}}}'],
+            [
+                {
+                    modificationTime: new Date(1234567890000),
+                    size: 1234,
+                    blockSizes: [4, 4, 4, 2],
+                    digests: {sha1: 'abcdef'},
+                },
+                '{"Common":{"ModificationTime":"2009-02-13T23:31:30.000Z","Size":1234,"BlockSizes":[4,4,4,2],"Digests":{"SHA1":"abcdef"}}}',
+            ],
+        ];
+        testCases.forEach(([input, expectedAttributes]) => {
+            it(`should generate ${input}`, () => {
+                const output = generateFileExtendedAttributes(input);
+                expect(output).toBe(expectedAttributes);
+            })
+        });
+    });
+
+    describe('should parses file attributes', () => {
+        const testCases: [string, FileExtendedAttributesParsed][] = [
+            ['', {}],
+            ['{}', {}],
+            ['a', {}],
+            [
+                '{"Common": {"ModificationTime": "2009-02-13T23:31:30+0000"}}',
+                {
+                    claimedModificationTime: new Date(1234567890000),
+                    claimedSize: undefined,
+                    claimedDigests: undefined,
+                    claimedAdditionalMetadata: undefined,
+                },
+            ],
+            [
+                '{"Common": {"Size": 123}}',
+                {
+                    claimedModificationTime: undefined,
+                    claimedSize: 123,
+                    claimedDigests: undefined,
+                    claimedAdditionalMetadata: undefined,
+                },
+            ],
+            [
+                '{"Common": {"ModificationTime": "2009-02-13T23:31:30+0000", "Size": 123, "BlockSizes": [1, 2, 3]}}',
+                {
+                    claimedModificationTime: new Date(1234567890000),
+                    claimedSize: 123,
+                    claimedDigests: undefined,
+                    claimedAdditionalMetadata: undefined,
+                },
+            ],
+            [
+                '{"Common": {"ModificationTime": "aa", "Size": 123}}',
+                {
+                    claimedModificationTime: undefined,
+                    claimedSize: 123,
+                    claimedDigests: undefined,
+                    claimedAdditionalMetadata: undefined,
+                },
+            ],
+            [
+                '{"Common": {"ModificationTime": "2009-02-13T23:31:30+0000", "Size": "aaa"}}',
+                {
+                    claimedModificationTime: new Date(1234567890000),
+                    claimedSize: undefined,
+                    claimedDigests: undefined,
+                    claimedAdditionalMetadata: undefined,
+                },
+            ],
+            [
+                '{"Common": {"Digests": {}}}',
+                {
+                    claimedModificationTime: undefined,
+                    claimedSize: undefined,
+                    claimedDigests: undefined,
+                    claimedAdditionalMetadata: undefined,
+                },
+            ],
+            [
+                '{"Common": {"Digests": {"SHA1": null}}}',
+                {
+                    claimedModificationTime: undefined,
+                    claimedSize: undefined,
+                    claimedDigests: undefined,
+                    claimedAdditionalMetadata: undefined,
+                },
+            ],
+            [
+                '{"Common": {"Digests": {"SHA1": "abcdef"}}}',
+                {
+                    claimedModificationTime: undefined,
+                    claimedSize: undefined,
+                    claimedDigests: {sha1: "abcdef"},
+                    claimedAdditionalMetadata: undefined,
+                },
+            ],
+            [
+                '{"Common": {}, "Media": {}}',
+                {
+                    claimedModificationTime: undefined,
+                    claimedSize: undefined,
+                    claimedDigests: undefined,
+                    claimedAdditionalMetadata: {
+                        Media: {},
+                    },
+                },
+            ],
+        ];
+        testCases.forEach(([input, expectedAttributes]) => {
+            it(`should parse ${input}`, () => {
+                const output = parseFileExtendedAttributes(getMockLogger(), input);
+                expect(output).toMatchObject(expectedAttributes);
+            })
+        });
+    });
+});

package/src/internal/nodes/extendedAttributes.ts

@@ -0,0 +1,180 @@
+import { Logger } from "../../interface";
+
+interface FolderExtendedAttributesSchema {
+    Common?: {
+        ModificationTime?: string;
+    };
+}
+
+interface FileExtendedAttributesSchema {
+    Common?: {
+        ModificationTime?: string;
+        Size?: number;
+        BlockSizes?: number[];
+        Digests?: {
+            SHA1: string;
+        };
+    };
+    Location?: {
+        Latitude?: number;
+        Longitude?: number;
+    };
+    Camera?: {
+        CaptureTime?: string;
+        Device?: string;
+        Orientation?: number;
+        SubjectCoordinates?: {
+            Top?: number;
+            Left?: number;
+            Bottom?: number;
+            Right?: number;
+        };
+    };
+    Media?: {
+        Width?: number;
+        Height?: number;
+        Duration?: number;
+    };
+}
+
+export interface FolderExtendedAttributes {
+    claimedModificationTime?: Date,
+}
+
+export interface FileExtendedAttributesParsed {
+    claimedSize?: number,
+    claimedModificationTime?: Date,
+    claimedDigests?: {
+        sha1?: string,
+    },
+    claimedAdditionalMetadata?: object,
+}
+
+export function generateFolderExtendedAttributes(claimedModificationTime?: Date): string | undefined {
+    if (!claimedModificationTime) {
+        return undefined;
+    }
+    return JSON.stringify({
+        Common: {
+            ModificationTime: dateToIsoString(claimedModificationTime),
+        },
+    });
+}
+
+function dateToIsoString(date: Date) {
+    const isDateValid = !Number.isNaN(date.getTime());
+    return isDateValid ? date.toISOString() : undefined;
+}
+
+export function parseFolderExtendedAttributes(logger: Logger, extendedAttributes?: string): FolderExtendedAttributes {
+    if (!extendedAttributes) {
+        return {};
+    }
+
+    try {
+        const parsed = JSON.parse(extendedAttributes) as FolderExtendedAttributesSchema;
+        return {
+            claimedModificationTime: parseModificationTime(logger, parsed),
+        };
+    } catch (error: unknown) {
+        logger.error(`Failed to parse extended attributes`, error);
+        return {};
+    }
+}
+
+export function generateFileExtendedAttributes(options: {
+    modificationTime?: Date,
+    size?: number,
+    blockSizes?: number[],
+    digests?: {
+        sha1?: string,
+    },
+}): string | undefined {
+    const commonAttributes: FileExtendedAttributesSchema['Common'] = {};
+    if (options.modificationTime) {
+        commonAttributes.ModificationTime = dateToIsoString(options.modificationTime);
+    }
+    if (options.size !== undefined) {
+        commonAttributes.Size = options.size;
+    }
+    if (options.blockSizes?.length) {
+        commonAttributes.BlockSizes = options.blockSizes;
+    }
+    if (options.digests?.sha1) {
+        commonAttributes.Digests = {
+            SHA1: options.digests.sha1,
+        };
+    }
+    if (!Object.keys(commonAttributes).length) {
+        return undefined;
+    }
+    return JSON.stringify({
+        Common: commonAttributes,
+    });
+}
+
+export function parseFileExtendedAttributes(logger: Logger, extendedAttributes?: string): FileExtendedAttributesParsed {
+    if (!extendedAttributes) {
+        return {}
+    }
+
+    try {
+        const parsed = JSON.parse(extendedAttributes) as FolderExtendedAttributesSchema;
+
+        const claimedAdditionalMetadata = { ...parsed };
+        delete claimedAdditionalMetadata.Common;
+
+        return {
+            claimedSize: parseSize(logger, parsed),
+            claimedModificationTime: parseModificationTime(logger, parsed),
+            claimedDigests: parseDigests(logger, parsed),
+            claimedAdditionalMetadata: Object.keys(claimedAdditionalMetadata).length ? claimedAdditionalMetadata : undefined,
+        };
+    } catch (error: unknown) {
+        logger.error(`Failed to parse extended attributes`, error);
+        return {};
+    }
+}
+
+function parseSize(logger: Logger, xattr?: FileExtendedAttributesSchema): number | undefined {
+    const size = xattr?.Common?.Size;
+    if (size === undefined) {
+        return undefined;
+    }
+    if (typeof size !== 'number') {
+        logger.warn(`XAttr file size "${size}" is not valid`);
+        return undefined;
+    }
+    return size;
+}
+
+function parseModificationTime(logger: Logger, xattr?: FolderExtendedAttributesSchema | FolderExtendedAttributesSchema): Date | undefined {
+    const modificationTime = xattr?.Common?.ModificationTime;
+    if (modificationTime === undefined) {
+        return undefined;
+    }
+    const modificationDate = new Date(modificationTime);
+    // This is the best way to check if date is "Invalid Date". :shrug:
+    if (JSON.stringify(modificationDate) === 'null') {
+        logger.warn(`XAttr modification time "${modificationTime}" is not valid`);
+        return undefined;
+    }
+    return modificationDate;
+}
+
+function parseDigests(logger: Logger, xattr?: FileExtendedAttributesSchema): { sha1: string } | undefined {
+    const digests = xattr?.Common?.Digests;
+    if (digests === undefined || digests.SHA1 === undefined) {
+        return undefined;
+    }
+
+    const sha1 = digests.SHA1;
+    if (typeof sha1 !== 'string') {
+        logger.warn(`XAttr digest SHA1 "${sha1}" is not valid`);
+        return undefined;
+    }
+
+    return {
+        sha1,
+    };
+}

package/src/internal/nodes/index.test.ts

@@ -0,0 +1,135 @@
+import { ProtonDriveEntitiesCache, ProtonDriveCryptoCache, ProtonDriveAccount, MemberRole, NodeType } from "../../interface";
+import { DriveCrypto } from "../../crypto";
+import { MemoryCache } from "../../cache";
+import { getMockTelemetry } from "../../tests/telemetry";
+import { DriveAPIService } from "../apiService";
+import { DriveEventsService, DriveListener, DriveEvent, DriveEventType } from "../events";
+import { makeNodeUid } from "../uids";
+import { SharesService, DecryptedNode } from "./interface";
+import { initNodesModule } from './index';
+
+function generateSerializedNode(uid: string, parentUid = 'volumeId~root', params: Partial<DecryptedNode> = {}): string {
+    return JSON.stringify(generateNode(uid, parentUid, params));
+}
+
+function generateNode(uid: string, parentUid = 'volumeId~root', params: Partial<DecryptedNode> = {}): DecryptedNode {
+    return {
+        uid,
+        parentUid,
+        directMemberRole: MemberRole.Admin,
+        type: NodeType.File,
+        mediaType: "text",
+        isShared: false,
+        creationTime: new Date(),
+        trashTime: undefined,
+        isStale: false,
+        ...params,
+    } as DecryptedNode;
+}
+
+describe('nodesModules integration tests', () => {
+    let apiService: DriveAPIService;
+    let driveEntitiesCache: ProtonDriveEntitiesCache;
+    let driveCryptoCache: ProtonDriveCryptoCache;
+    let account: ProtonDriveAccount;
+    let driveCrypto: DriveCrypto;
+    let eventCallbacks: DriveListener[];
+    let driveEvents: DriveEventsService;
+    let sharesService: SharesService;
+    let nodesModule: ReturnType<typeof initNodesModule>;
+
+    beforeEach(() => {
+        // @ts-expect-error No need to implement all methods for mocking
+        apiService = {}
+        driveEntitiesCache = new MemoryCache();
+        driveCryptoCache = new MemoryCache();
+        // @ts-expect-error No need to implement all methods for mocking
+        account = {}
+        // @ts-expect-error No need to implement all methods for mocking
+        driveCrypto = {}
+        eventCallbacks = [];
+        // @ts-expect-error No need to implement all methods for mocking
+        driveEvents = {
+            addListener: jest.fn().mockImplementation((callback) => {
+                eventCallbacks.push(callback);
+            }),
+        }
+        // @ts-expect-error No need to implement all methods for mocking
+        sharesService = {}
+
+        nodesModule = initNodesModule(
+            getMockTelemetry(),
+            apiService,
+            driveEntitiesCache,
+            driveCryptoCache,
+            account,
+            driveCrypto,
+            driveEvents,
+            sharesService,
+        );
+    });
+
+    test('should move node from one folder to another after move event', async () => {
+        // Prepare two folders (original and target) and a node in the original folder.
+        const originalFolderUid = makeNodeUid('volumeId', 'originalFolder');
+        await driveEntitiesCache.setEntity(`node-${originalFolderUid}`, generateSerializedNode(originalFolderUid));
+        await driveEntitiesCache.setEntity(`node-children-${originalFolderUid}`, 'loaded');
+
+        const targetFolderUid = makeNodeUid('volumeId', 'targetFolder');
+        await driveEntitiesCache.setEntity(`node-${targetFolderUid}`, generateSerializedNode(targetFolderUid));
+        await driveEntitiesCache.setEntity(`node-children-${targetFolderUid}`, 'loaded');
+
+        const nodeUid = makeNodeUid('volumeId', 'node1');
+        await driveEntitiesCache.setEntity(`node-${nodeUid}`, generateSerializedNode(nodeUid, originalFolderUid), [`nodeParentUid:${originalFolderUid}`]);
+
+        // Mock the API services to return the moved node.
+        // This is called when listing the children of the target folder after
+        // move event (when node marked as stale).
+        apiService.post = jest.fn().mockImplementation(async (url, body) => {
+            expect(url).toBe(`drive/v2/volumes/volumeId/links`);
+            return {
+                Links: [{
+                    Link: {
+                        LinkID: 'node1',
+                        ParentLinkID: 'targetFolder',
+                        NameHash: 'hash',
+                        Type: 2,
+                    },
+                    File: {
+                        ActiveRevision: {},
+                    },
+                }],
+            };
+        });
+        jest.spyOn(nodesModule.access, 'getParentKeys').mockResolvedValue({ key: { _idx: 32131 } } as any);
+
+        // Verify the inital state before move event is sent.
+        const originalBeforeMove = await Array.fromAsync(nodesModule.access.iterateFolderChildren(originalFolderUid));
+        expect(originalBeforeMove).toMatchObject([{ uid: nodeUid, parentUid: originalFolderUid }]);
+
+        const targetBeforeMove = await Array.fromAsync(nodesModule.access.iterateFolderChildren(targetFolderUid));
+        expect(targetBeforeMove).toMatchObject([]);
+
+        // Send the move event that updates the cache.
+        const events: DriveEvent[] = [
+            {
+                type: DriveEventType.NodeUpdated,
+                nodeUid,
+                parentNodeUid: targetFolderUid,
+                isTrashed: false,
+                isShared: false,
+                isOwnVolume: true,
+            },
+        ]
+        await Promise.all(eventCallbacks.map((callback) => callback(events)));
+
+        // Verify the state after the move event, including when API service is called.
+        const originalAfterMove = await Array.fromAsync(nodesModule.access.iterateFolderChildren(originalFolderUid));
+        expect(originalAfterMove).toMatchObject([]);
+        expect(apiService.post).not.toHaveBeenCalled();
+
+        const targetAfterMove = await Array.fromAsync(nodesModule.access.iterateFolderChildren(targetFolderUid));
+        expect(targetAfterMove).toMatchObject([{ uid: nodeUid, parentUid: targetFolderUid }]);
+        expect(apiService.post).toHaveBeenCalledTimes(1);
+    });
+});

package/src/internal/nodes/index.ts

@@ -0,0 +1,52 @@
+import { DriveAPIService } from "../apiService";
+import { DriveCrypto } from "../../crypto";
+import { DriveEventsService } from "../events";
+import { ProtonDriveEntitiesCache, ProtonDriveCryptoCache, ProtonDriveAccount, ProtonDriveTelemetry } from "../../interface";
+import { NodeAPIService } from "./apiService";
+import { NodesCache } from "./cache";
+import { NodesEvents } from "./events";
+import { NodesCryptoCache } from "./cryptoCache";
+import { NodesCryptoService } from "./cryptoService";
+import { SharesService } from "./interface";
+import { NodesAccess } from "./nodesAccess";
+import { NodesManagement } from "./nodesManagement";
+import { NodesRevisons } from "./nodesRevisions";
+
+export type { DecryptedNode } from "./interface";
+export { generateFileExtendedAttributes } from "./extendedAttributes";
+
+/**
+ * Provides facade for the whole nodes module.
+ * 
+ * The nodes module is responsible for handling node metadata, including
+ * API communication, encryption, decryption, caching, and event handling.
+ * 
+ * This facade provides internal interface that other modules can use to
+ * interact with the nodes.
+ */
+export function initNodesModule(
+    telemetry: ProtonDriveTelemetry,
+    apiService: DriveAPIService,
+    driveEntitiesCache: ProtonDriveEntitiesCache,
+    driveCryptoCache: ProtonDriveCryptoCache,
+    account: ProtonDriveAccount,
+    driveCrypto: DriveCrypto,
+    driveEvents: DriveEventsService,
+    sharesService: SharesService,
+) {
+    const api = new NodeAPIService(telemetry.getLogger('nodes-api'), apiService);
+    const cache = new NodesCache(telemetry.getLogger('nodes-cache'), driveEntitiesCache);
+    const cryptoCache = new NodesCryptoCache(telemetry.getLogger('nodes-cache'), driveCryptoCache);
+    const cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, sharesService);
+    const nodesAccess = new NodesAccess(telemetry.getLogger('nodes'), api, cache, cryptoCache, cryptoService, sharesService);
+    const nodesEvents = new NodesEvents(telemetry.getLogger('nodes-events'), driveEvents, cache, nodesAccess);
+    const nodesManagement = new NodesManagement(api, cryptoCache, cryptoService, nodesAccess, nodesEvents);
+    const nodesRevisions = new NodesRevisons(telemetry.getLogger('nodes'), api, cryptoService, nodesAccess);
+
+    return {
+        access: nodesAccess,
+        management: nodesManagement,
+        revisions: nodesRevisions,
+        events: nodesEvents,
+    };
+}

package/src/internal/nodes/interface.ts

@@ -0,0 +1,152 @@
+import { PrivateKey, SessionKey } from "../../crypto";
+import { NodeEntity, Result, InvalidNameError, Author, MemberRole, NodeType, ThumbnailType, MetricContext, Revision, RevisionState } from "../../interface";
+
+/**
+ * Internal common node interface for both encrypted or decrypted node.
+ */
+interface BaseNode {
+    // Internal metadata
+    hash?: string; // root node doesn't have any hash
+    encryptedName: string;
+
+    // Basic node metadata
+    uid: string;
+    parentUid?: string;
+    type: NodeType;
+    mediaType?: string;
+    creationTime: Date; // created on the server
+    trashTime?: Date;
+    totalStorageSize?: number;
+
+    // Share node metadata
+    shareId?: string;
+    isShared: boolean,
+    directMemberRole: MemberRole,
+}
+
+/**
+ * Interface used only internaly in the nodes module.
+ * 
+ * Outside of the module, the decrypted node interface should be used.
+ */
+export interface EncryptedNode extends BaseNode {
+    encryptedCrypto: EncryptedNodeFolderCrypto | EncryptedNodeFileCrypto;
+}
+
+export interface EncryptedNodeCrypto {
+    signatureEmail?: string;
+    nameSignatureEmail?: string;
+    armoredKey: string;
+    armoredNodePassphrase: string;
+    armoredNodePassphraseSignature: string;
+}
+
+export interface EncryptedNodeFileCrypto extends EncryptedNodeCrypto {
+    file: {
+        base64ContentKeyPacket: string;
+        armoredContentKeyPacketSignature?: string;
+    };
+    activeRevision: EncryptedRevision;
+}
+
+export interface EncryptedNodeFolderCrypto extends EncryptedNodeCrypto {
+    folder: {
+        armoredExtendedAttributes?: string;
+        armoredHashKey: string;
+    };
+}
+
+/**
+ * Interface used only internally in the nodes module.
+ *
+ * Outside of the module, the decrypted node interface should be used.
+ *
+ * This interface is holding decrypted node metadata that is not yet parsed,
+ * such as extended attributes.
+ */
+export interface DecryptedUnparsedNode extends BaseNode {
+    keyAuthor: Author,
+    nameAuthor: Author,
+    name: Result<string, Error>,
+    activeRevision?: Result<DecryptedUnparsedRevision, Error>,
+    folder?: {
+        extendedAttributes?: string,
+    },
+    errors?: unknown[],
+}
+
+/**
+ * Interface holding decrypted node metadata.
+ */
+export interface DecryptedNode extends Omit<DecryptedUnparsedNode, 'name' | 'activeRevision' | 'folder'>, Omit<NodeEntity, 'name' | 'activeRevision'> {
+    // Internal metadata
+    isStale: boolean;
+    name: Result<string, Error | InvalidNameError>,
+
+    activeRevision?: Result<DecryptedRevision, Error>,
+    folder?: {
+        claimedModificationTime?: Date,
+    },
+}
+
+/**
+ * Interface holding decrypted node key, including session key, and hash key.
+ *
+ * These keys are cached as they are needed for various actions on the node.
+ * 
+ * Passphrase, for example, might be removed at some point. It is needed as
+ * at this moment the move requires both node key passphrase and the session
+ * key.
+ */
+export interface DecryptedNodeKeys {
+    passphrase: string;
+    key: PrivateKey;
+    passphraseSessionKey: SessionKey;
+    contentKeyPacketSessionKey?: SessionKey;
+    hashKey?: Uint8Array;
+}
+
+interface BaseRevision {
+    uid: string;
+    state: RevisionState;
+    creationTime: Date; // created on the server
+    storageSize: number;
+    thumbnails: Thumbnail[];
+}
+
+export type Thumbnail = {
+    uid: string;
+    type: ThumbnailType;
+}
+
+export interface EncryptedRevision extends BaseRevision {
+    signatureEmail?: string;
+    armoredExtendedAttributes?: string;
+}
+
+export interface DecryptedUnparsedRevision extends BaseRevision {
+    contentAuthor: Author,
+    extendedAttributes?: string,
+}
+
+export interface DecryptedRevision extends Revision {
+    thumbnails?: Thumbnail[];
+}
+
+/**
+ * Interface describing the dependencies to the shares module.
+ */
+export interface SharesService {
+    getMyFilesIDs(): Promise<{ volumeId: string, rootNodeId: string }>,
+    getSharePrivateKey(shareId: string): Promise<PrivateKey>,
+    getMyFilesShareMemberEmailKey(): Promise<{
+        email: string,
+    }>,
+    getContextShareMemberEmailKey(shareId: string): Promise<{
+        email: string,
+        addressId: string,
+        addressKey: PrivateKey,
+        addressKeyId: string,
+    }>,
+    getVolumeMetricContext(volumeId: string): Promise<MetricContext>,
+}