@protontech/drive-sdk 0.0.10

package/src/internal/apiService/errorCodes.ts

@@ -0,0 +1,38 @@
+export const enum HTTPErrorCode {
+    OK = 200,
+    NOT_FOUND = 404,
+    TOO_MANY_REQUESTS = 429,
+    INTERNAL_SERVER_ERROR = 500,
+}
+
+export function isCodeOk(code: number): boolean {
+    return code === ErrorCode.OK || code === ErrorCode.OK_MANY || code === ErrorCode.OK_ASYNC;
+}
+
+export function isCodeOkAsync(code: number): boolean {
+    return code === ErrorCode.OK_ASYNC;
+}
+
+export const enum ErrorCode {
+    OK = 1000,
+    OK_MANY = 1001,
+    OK_ASYNC = 1002,
+    NOT_ENOUGH_PERMISSIONS = 2011,
+    NOT_ENOUGH_PERMISSIONS_TO_GRANT_PERMISSIONS = 2026,
+    // Following codes takes name from the API documentation.
+    ALREADY_EXISTS = 2500,
+    NOT_EXISTS = 2501,
+    INSUFFICIENT_QUOTA = 200001,	
+    INSUFFICIENT_SPACE = 200002,
+    MAX_FILE_SIZE_FOR_FREE_USER = 200003,
+    MAX_PUBLIC_EDIT_MODE_FOR_FREE_USER = 200004,
+    INSUFFICIENT_VOLUME_QUOTA= 200100,
+    INSUFFICIENT_DEVICE_QUOTA= 200101,
+    ALREADY_MEMBER_OF_SHARE_IN_VOLUME_WITH_ANOTHER_ADDRESS = 200201,
+    TOO_MANY_CHILDREN = 200300,
+    NESTING_TOO_DEEP = 200301,
+    INSUFFICIENT_INVITATION_QUOTA = 200600,	
+    INSUFFICIENT_SHARE_QUOTA = 200601,
+    INSUFFICIENT_SHARE_JOINED_QUOTA = 200602,
+    INSUFFICIENT_BOOKMARKS_QUOTA = 200800,
+}

package/src/internal/apiService/errors.test.ts

@@ -0,0 +1,63 @@
+import { apiErrorFactory } from "./errors";
+import * as errors from "./errors";
+import { ErrorCode } from './errorCodes';
+
+function mockAPIResponseAndResult(options: {
+    httpStatusCode?: number,
+    httpStatusText?: string,
+    code: number,
+    message?: string,
+}) {
+    const {
+        httpStatusCode = 422,
+        httpStatusText = 'Unprocessable Entity',
+        code,
+        message = 'API error',
+    } = options;
+
+    const result = { Code: code, Error: message };
+    const response = new Response(JSON.stringify(result), { status: httpStatusCode, statusText: httpStatusText });
+
+    return { response, result };
+}
+
+describe("apiErrorFactory should return", () => {
+    it("generic APIHTTPError when there is no specifc body", () => {
+        const response = new Response('', { status: 404, statusText: 'Not found' });
+        const error = apiErrorFactory({ response });
+        expect(error).toBeInstanceOf(errors.APIHTTPError);
+        expect(error.message).toBe("Not found");
+        expect((error as errors.APIHTTPError).statusCode).toBe(404);
+    });
+
+    it("generic APIHTTPError when there 404 both in status code and body code", () => {
+        const error = apiErrorFactory(mockAPIResponseAndResult({ httpStatusCode: 404, httpStatusText: 'Path not found', code: 404, message: 'Not found' }));
+        expect(error).toBeInstanceOf(errors.APIHTTPError);
+        expect(error.message).toBe("Path not found");
+        expect((error as errors.APIHTTPError).statusCode).toBe(404);
+    });
+
+    it("generic APICodeError when there is body even if wrong", () => {
+        const result = {};
+        const response = new Response('', { status: 422 });
+        const error = apiErrorFactory({ response, result });
+        expectAPICodeError(error, 0, 'Unknown error');
+    });
+
+    it("generic APICodeError when there is body but not specific handle", () => {
+        const error = apiErrorFactory(mockAPIResponseAndResult({ code: 42, message: 'General error' }));
+        expectAPICodeError(error, 42, 'General error');
+    });
+
+    it("NotFoundAPIError when code is ErrorCode.NOT_EXISTS", () => {
+        const error = apiErrorFactory(mockAPIResponseAndResult({ code: ErrorCode.NOT_EXISTS, message: 'Not found' }));
+        expect(error).toBeInstanceOf(errors.NotFoundAPIError);
+        expectAPICodeError(error, ErrorCode.NOT_EXISTS, 'Not found');
+    });
+});
+
+function expectAPICodeError(error: Error, code: number, message: string) {
+    expect(error).toBeInstanceOf(errors.APICodeError);
+    expect(error.message).toBe(message);
+    expect((error as errors.APICodeError).code).toBe(code);
+}

package/src/internal/apiService/errors.ts

@@ -0,0 +1,91 @@
+import { c } from 'ttag';
+
+import { ServerError, ValidationError } from '../../errors';
+import { ErrorCode, HTTPErrorCode } from './errorCodes';
+
+export function apiErrorFactory({ response, result }: { response: Response, result?: unknown }): ServerError {
+    // Backend responses with 404 both in the response and body code.
+    // In such a case we want to stick to APIHTTPError to be very clear
+    // it is not NotFoundAPIError.
+    if (response.status === HTTPErrorCode.NOT_FOUND || !result) {
+        return new APIHTTPError(response.statusText, response.status);
+    }
+
+    const typedResult = result as {
+        Code?: number;
+        Error?: string;
+        exception?: string;
+        message?: string;
+        file?: string;
+        line?: number;
+        trace?: object;
+    };
+
+    const [code, message] = [typedResult.Code || 0, typedResult.Error || c('Error').t`Unknown error`];
+
+    const debug = typedResult.exception ? {
+        exception: typedResult.exception,
+        message: typedResult.message,
+        file: typedResult.file,
+        line: typedResult.line,
+        trace: typedResult.trace,
+    } : undefined;
+
+    switch (code) {
+        case ErrorCode.NOT_EXISTS:
+            return new NotFoundAPIError(message, code);
+        // ValidationError should be only when it is clearly user input error,
+        // otherwise it should be ServerError.
+        // Here we convert only general enough codes. Specific cases that are
+        // not clear from the code itself must be handled by each module
+        // separately.
+        case ErrorCode.NOT_ENOUGH_PERMISSIONS:
+        case ErrorCode.NOT_ENOUGH_PERMISSIONS_TO_GRANT_PERMISSIONS:
+        case ErrorCode.ALREADY_EXISTS:
+        case ErrorCode.INSUFFICIENT_QUOTA:
+        case ErrorCode.INSUFFICIENT_SPACE:
+        case ErrorCode.MAX_FILE_SIZE_FOR_FREE_USER:
+        case ErrorCode.MAX_PUBLIC_EDIT_MODE_FOR_FREE_USER:
+        case ErrorCode.INSUFFICIENT_VOLUME_QUOTA:
+        case ErrorCode.INSUFFICIENT_DEVICE_QUOTA:
+        case ErrorCode.ALREADY_MEMBER_OF_SHARE_IN_VOLUME_WITH_ANOTHER_ADDRESS:
+        case ErrorCode.TOO_MANY_CHILDREN:
+        case ErrorCode.NESTING_TOO_DEEP:
+        case ErrorCode.INSUFFICIENT_INVITATION_QUOTA:
+        case ErrorCode.INSUFFICIENT_SHARE_QUOTA:
+        case ErrorCode.INSUFFICIENT_SHARE_JOINED_QUOTA:
+        case ErrorCode.INSUFFICIENT_BOOKMARKS_QUOTA:
+            return new ValidationError(message, code);
+        default:
+            return new APICodeError(message, code, debug);
+    }
+}
+
+export class APIHTTPError extends ServerError {
+    name = 'APIHTTPError';
+
+    public readonly statusCode: number;
+
+    constructor(message: string, statusCode: number) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+
+export class APICodeError extends ServerError {
+    name = 'APICodeError';
+
+    public readonly code: number;
+
+    public readonly debug?: object;
+
+    constructor(message: string, code: number, debug?: object) {
+        super(message);
+        this.code = code;
+        this.debug = debug;
+    }
+}
+
+export class NotFoundAPIError extends APICodeError {
+    name = 'NotFoundAPIError';
+}

package/src/internal/apiService/index.ts

@@ -0,0 +1,7 @@
+export { DriveAPIService } from './apiService';
+export type { paths as drivePaths } from './driveTypes';
+export type { paths as corePaths } from './coreTypes';
+export { HTTPErrorCode, ErrorCode, isCodeOk, isCodeOkAsync } from './errorCodes';
+export { nodeTypeNumberToNodeType, permissionsToDirectMemberRole, memberRoleToPermission } from './transformers';
+export { ObserverStream } from './observerStream';
+export * from './errors';

package/src/internal/apiService/observerStream.ts

@@ -0,0 +1,10 @@
+export class ObserverStream extends TransformStream<Uint8Array, Uint8Array> {
+    constructor(fn?: (chunk: Uint8Array) => void) {
+        super({
+            transform(chunk, controller) {
+                fn?.(chunk);
+                controller.enqueue(chunk);
+            },
+        });
+    }
+}

package/src/internal/apiService/transformers.ts

@@ -0,0 +1,45 @@
+import { Logger, NodeType, MemberRole } from "../../interface";
+
+export function nodeTypeNumberToNodeType(logger: Logger, nodeTypeNumber: number): NodeType {
+    switch (nodeTypeNumber) {
+        case 1:
+            return NodeType.Folder;
+        case 2:
+            return NodeType.File;
+        default:
+            logger.warn(`Unknown node type: ${nodeTypeNumber}`);
+            return NodeType.File;
+    }
+}
+
+export function permissionsToDirectMemberRole(logger: Logger, permissionsNumber?: number): MemberRole {
+    switch (permissionsNumber) {
+        case undefined:
+            return MemberRole.Inherited;
+        case 4:
+            return MemberRole.Viewer;
+        case 6:
+            return MemberRole.Editor;
+        case 22:
+            return MemberRole.Admin;
+        default:
+            // User have access to the data, thus at minimum it can view.
+            logger.warn(`Unknown sharing permissions: ${permissionsNumber}`);
+            return MemberRole.Viewer;
+    }
+}
+
+export function memberRoleToPermission(memberRole: MemberRole): 4 | 6 | 22 {
+    if (memberRole === MemberRole.Inherited) {
+        // This is developer error.
+        throw new Error("Cannot convert inherited role to permission");
+    }
+    switch (memberRole) {
+        case MemberRole.Viewer:
+            return 4;
+        case MemberRole.Editor:
+            return 6;
+        case MemberRole.Admin:
+            return 22;
+    }
+}

package/src/internal/batchLoading.test.ts

@@ -0,0 +1,58 @@
+import { BatchLoading } from './batchLoading';
+
+describe("BatchLoading", () => {
+    let batchLoading: BatchLoading<string, string>;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it("should load in batches with loadItems", async () => {
+        const loadItems = jest.fn((items: string[]) => Promise.resolve(items.map((item) => `loaded:${item}`)));
+
+        batchLoading = new BatchLoading<string, string>({ loadItems, batchSize: 2 });
+
+        const result = [];
+        for (const item of ["a", "b", "c", "d", "e"]) {
+            for await (const loadedItem of batchLoading.load(item)) {
+                result.push(loadedItem);
+            }
+        }
+        for await (const loadedItem of batchLoading.loadRest()) {
+            result.push(loadedItem);
+        }
+
+
+        expect(result).toEqual(["loaded:a", "loaded:b", "loaded:c", "loaded:d", "loaded:e"]);
+        expect(loadItems).toHaveBeenCalledTimes(3);
+        expect(loadItems).toHaveBeenNthCalledWith(1, ["a", "b"]);
+        expect(loadItems).toHaveBeenNthCalledWith(2, ["c", "d"]);
+        expect(loadItems).toHaveBeenNthCalledWith(3, ["e"]);
+    });
+
+    it("should load in batches with iterateItems", async () => {
+        const iterateItems = jest.fn(async function* (items: string[]) {
+            for (const item of items) {
+                yield `loaded:${item}`;
+            }
+        });
+
+        batchLoading = new BatchLoading<string, string>({ iterateItems, batchSize: 2 });
+
+        const result = [];
+        for (const item of ["a", "b", "c", "d", "e"]) {
+            for await (const loadedItem of batchLoading.load(item)) {
+                result.push(loadedItem);
+            }
+        }
+        for await (const loadedItem of batchLoading.loadRest()) {
+            result.push(loadedItem);
+        }
+
+        expect(result).toEqual(["loaded:a", "loaded:b", "loaded:c", "loaded:d", "loaded:e"]);
+        expect(iterateItems).toHaveBeenCalledTimes(3);
+        expect(iterateItems).toHaveBeenNthCalledWith(1, ["a", "b"]);
+        expect(iterateItems).toHaveBeenNthCalledWith(2, ["c", "d"]);
+        expect(iterateItems).toHaveBeenNthCalledWith(3, ["e"]);
+    });
+});

package/src/internal/batchLoading.ts

@@ -0,0 +1,74 @@
+const DEFAULT_BATCH_LOADING = 10;
+
+/**
+ * Helper class for batch loading items.
+ * 
+ * The class is responsible for fetching items in batches. Any call to
+ * `load` will add the item to the batch (without fetching anything),
+ * and if the batch reaches the limit, it will fetch the items and yield
+ * them transparently to the caller.
+ * 
+ * Example:
+ * 
+ * ```typescript
+ * const batchLoading = new BatchLoading<string, DecryptedNode>({ loadItems: loadNodesCallback });
+ * for (const nodeUid of nodeUids) {
+ *   for await (const node of batchLoading.load(nodeUid)) {
+ *     console.log(node);
+ *   }
+ * }
+ * for await (const node of batchLoading.loadRest()) {
+ *  console.log(node);
+ * }
+ * ```
+ */
+export class BatchLoading<ID, ITEM> {
+    private batchSize = DEFAULT_BATCH_LOADING;
+    private iterateItems: (ids: ID[]) => AsyncGenerator<ITEM>;
+
+    private itemsToFetch: ID[];
+
+    constructor(options: {
+        loadItems?: (ids: ID[]) => Promise<ITEM[]>,
+        iterateItems?: (ids: ID[]) => AsyncGenerator<ITEM>,
+        batchSize?: number,
+    }) {
+        this.itemsToFetch = [];
+        
+        if (options.loadItems) {
+            const loadItems = options.loadItems;
+            this.iterateItems = async function* (ids: ID[]) {
+                for (const item of await loadItems(ids)) {
+                    yield item;
+                }
+            }
+        } else if (options.iterateItems) {
+            this.iterateItems = options.iterateItems;
+        } else {
+            // This is developer error.
+            throw new Error('Either loadItems or iterateItems must be provided');
+        }
+
+        if (options.batchSize) {
+            this.batchSize = options.batchSize;
+        }
+    }
+
+    async *load(nodeUid: ID) {
+        this.itemsToFetch.push(nodeUid);
+
+        if (this.itemsToFetch.length >= this.batchSize) {
+            yield* this.iterateItems(this.itemsToFetch);
+            this.itemsToFetch = [];
+        }
+    }
+
+    async *loadRest() {
+        if (this.itemsToFetch.length === 0) {
+            return;
+        }
+
+        yield* this.iterateItems(this.itemsToFetch);
+        this.itemsToFetch = [];
+    }
+}

package/src/internal/devices/apiService.ts

@@ -0,0 +1,142 @@
+import { DeviceType } from "../../interface";
+import { DriveAPIService, drivePaths } from "../apiService";
+import { makeDeviceUid, makeNodeUid, splitDeviceUid } from "../uids";
+import { DeviceMetadata } from "./interface";
+
+type GetDevicesResponse = drivePaths['/drive/devices']['get']['responses']['200']['content']['application/json'];
+
+type PostCreateDeviceRequest = Extract<drivePaths['/drive/devices']['post']['requestBody'], { 'content': object }>['content']['application/json'];
+type PostCreateDeviceResponse = drivePaths['/drive/devices']['post']['responses']['200']['content']['application/json'];
+
+type PutUpdateDeviceRequest = Extract<drivePaths['/drive/devices/{deviceID}']['put']['requestBody'], { 'content': object }>['content']['application/json'];
+type PutUpdateDeviceResponse = drivePaths['/drive/devices/{deviceID}']['put']['responses']['200']['content']['application/json'];
+
+/**
+ * Provides API communication for managing devices.
+ * 
+ * The service is responsible for transforming local objects to API payloads
+ * and vice versa. It should not contain any business logic.
+ */
+export class DevicesAPIService {
+    constructor(private apiService: DriveAPIService) {
+        this.apiService = apiService;
+    }
+
+    async getDevices(signal?: AbortSignal): Promise<DeviceMetadata[]> {
+        const response = await this.apiService.get<GetDevicesResponse>('drive/devices', signal);
+        return response.Devices.map((device) => ({
+            uid: makeDeviceUid(device.Device.VolumeID, device.Device.DeviceID),
+            type: deviceTypeNumberToEnum(device.Device.Type),
+            rootFolderUid: makeNodeUid(device.Device.VolumeID, device.Share.LinkID),
+            creationTime: new Date(device.Device.CreateTime*1000),
+            lastSyncTime: device.Device.LastSyncTime ? new Date(device.Device.LastSyncTime*1000) : undefined,
+            hasDeprecatedName: !!device.Share.Name,
+            /** @deprecated to be removed once Volume-based navigation is implemented in web */
+            shareId: device.Share.ShareID,
+        }));
+    }
+
+    /**
+     * Originally the device name was on the share of the device.
+     * This was changed to be on the root node of the device instead.
+     * Old devices will still have the name on the share and when
+     * the client renames the device, it must be removed on the device.
+     */
+    async removeNameFromDevice(deviceUid: string): Promise<void> {
+        const { deviceId } = splitDeviceUid(deviceUid);
+        await this.apiService.put<
+            // Web clients do not update Device fields, that is only for desktop clients.
+            Omit<PutUpdateDeviceRequest, 'Device'>,
+            PutUpdateDeviceResponse
+        >(
+            `drive/devices/${deviceId}`,
+            {
+                Share: { Name: "" },
+            },
+        );
+    }
+
+    async createDevice(
+        device: {
+            volumeId: string,
+            type: DeviceType,
+        },
+        share: {
+            addressId: string,
+            addressKeyId: string,
+            armoredKey: string,
+            armoredSharePassphrase: string,
+            armoredSharePassphraseSignature: string,
+        },
+        node: {
+            encryptedName: string,
+            armoredKey: string,
+            armoredNodePassphrase: string,
+            armoredNodePassphraseSignature: string,
+            armoredHashKey: string,
+        }
+    ): Promise<DeviceMetadata> {
+        const response = await this.apiService.post<PostCreateDeviceRequest, PostCreateDeviceResponse>('drive/devices', {
+            // @ts-expect-error VolumeID is deprecated.
+            Device: {
+                Type: deviceTypeEnumToNumber(device.type),
+                SyncState: 0,
+            },
+            // @ts-expect-error Name is deprecated.
+            Share: {
+                AddressID: share.addressId,
+                AddressKeyID: share.addressKeyId,
+                Key: share.armoredKey,
+                Passphrase: share.armoredSharePassphrase,
+                PassphraseSignature: share.armoredSharePassphraseSignature,
+            },
+            Link: {
+                Name: node.encryptedName,
+                NodeKey: node.armoredKey,
+                NodePassphrase: node.armoredNodePassphrase,
+                NodePassphraseSignature: node.armoredNodePassphraseSignature,
+                NodeHashKey: node.armoredHashKey,
+            }
+        });
+
+        return {
+            uid: makeDeviceUid(device.volumeId, response.Device.DeviceID),
+            type: device.type,
+            rootFolderUid: makeNodeUid(device.volumeId, response.Device.LinkID),
+            creationTime: new Date(),
+            hasDeprecatedName: false,
+            shareId: response.Device.ShareID,
+        }
+    }
+
+    async deleteDevice(deviceUid: string): Promise<void> {
+        const { deviceId } = splitDeviceUid(deviceUid);
+        await this.apiService.delete(`drive/devices/${deviceId}`);
+    }
+}
+
+function deviceTypeNumberToEnum(deviceType: 1 | 2 | 3): DeviceType {
+    switch (deviceType) {
+        case 1:
+            return DeviceType.Windows;
+        case 2:
+            return DeviceType.MacOS;
+        case 3:
+            return DeviceType.Linux;
+        default:
+            throw new Error(`Unknown device type: ${deviceType}`);
+    }
+}
+
+function deviceTypeEnumToNumber(deviceType: DeviceType): 1 | 2 | 3 {
+    switch (deviceType.toLowerCase()) {
+        case DeviceType.Windows.toLowerCase():
+            return 1;
+        case DeviceType.MacOS.toLowerCase():
+            return 2;
+        case DeviceType.Linux.toLowerCase():
+            return 3;
+        default:
+            throw new Error(`Unknown device type: ${deviceType}`);
+    }
+}

package/src/internal/devices/cryptoService.ts

@@ -0,0 +1,65 @@
+import { DriveCrypto } from '../../crypto';
+import { SharesService } from './interface';
+
+/**
+ * Provides crypto operations for devices.
+ */
+export class DevicesCryptoService {
+    constructor(
+        private driveCrypto: DriveCrypto,
+        private sharesService: SharesService,
+    ) {
+        this.driveCrypto = driveCrypto;
+        this.sharesService = sharesService;
+    }
+
+    async createDevice(deviceName: string): Promise<{
+        address: {
+            addressId: string,
+            addressKeyId: string,
+        },
+        shareKey: {
+            armoredKey: string,
+            armoredPassphrase: string,
+            armoredPassphraseSignature: string,
+        },
+        node: {
+            key: {
+                armoredKey: string,
+                armoredPassphrase: string,
+                armoredPassphraseSignature: string,
+            },
+            encryptedName: string,
+            armoredHashKey: string,
+        }
+    }> {
+        const address = await this.sharesService.getMyFilesShareMemberEmailKey();
+        const addressKey = address.addressKey;
+
+        const shareKey = await this.driveCrypto.generateKey([addressKey], addressKey);
+        const rootNodeKey = await this.driveCrypto.generateKey([shareKey.decrypted.key], addressKey);
+        const { armoredNodeName } = await this.driveCrypto.encryptNodeName(deviceName, undefined, shareKey.decrypted.key, addressKey);
+        const { armoredHashKey } = await this.driveCrypto.generateHashKey(rootNodeKey.decrypted.key);
+
+        return {
+            address: {
+                addressId: address.addressId,
+                addressKeyId: address.addressKeyId,
+            },
+            shareKey: {
+                armoredKey: shareKey.encrypted.armoredKey,
+                armoredPassphrase: shareKey.encrypted.armoredPassphrase,
+                armoredPassphraseSignature: shareKey.encrypted.armoredPassphraseSignature,
+            },
+            node: {
+                key: {
+                    armoredKey: rootNodeKey.encrypted.armoredKey,
+                    armoredPassphrase: rootNodeKey.encrypted.armoredPassphrase,
+                    armoredPassphraseSignature: rootNodeKey.encrypted.armoredPassphraseSignature,
+                },
+                encryptedName: armoredNodeName,
+                armoredHashKey,
+            }
+        };
+    };
+}

package/src/internal/devices/index.ts

@@ -0,0 +1,31 @@
+import { DriveCrypto } from "../../crypto";
+import { ProtonDriveTelemetry } from "../../interface";
+import { DriveAPIService } from "../apiService";
+import { DevicesAPIService } from "./apiService";
+import { DevicesCryptoService } from "./cryptoService";
+import { SharesService, NodesService, NodesManagementService } from "./interface";
+import { DevicesManager } from "./manager";
+
+/**
+ * Provides facade for the whole devices module.
+ * 
+ * The devices module is responsible for handling devices metadata, including
+ * API communication, encryption, decryption, caching, and event handling.
+ * 
+ * This facade provides internal interface that other modules can use to
+ * interact with the devices.
+ */
+export function initDevicesModule(
+    telemetry: ProtonDriveTelemetry,
+    apiService: DriveAPIService,
+    driveCrypto: DriveCrypto,
+    sharesService: SharesService,
+    nodesService: NodesService,
+    nodesManagementService: NodesManagementService,
+) {
+    const api = new DevicesAPIService(apiService);
+    const cryptoService = new DevicesCryptoService(driveCrypto, sharesService);
+    const manager = new DevicesManager(telemetry.getLogger('devices'), api, cryptoService, sharesService, nodesService, nodesManagementService);
+
+    return manager;
+}

package/src/internal/devices/interface.ts

@@ -0,0 +1,28 @@
+import { PrivateKey } from "../../crypto";
+import { DeviceType, MissingNode } from "../../interface";
+import { DecryptedNode } from "../nodes";
+
+export type DeviceMetadata = {
+    uid: string,
+    type: DeviceType
+    rootFolderUid: string,
+    creationTime: Date,
+    lastSyncTime?: Date;
+    hasDeprecatedName: boolean;
+    shareId: string;
+}
+
+export interface SharesService {
+    getMyFilesIDs(): Promise<{ volumeId: string }>;
+    getMyFilesShareMemberEmailKey(): Promise<{ addressId: string, email: string, addressKey: PrivateKey, addressKeyId: string }>,
+}
+
+export interface NodesService {
+    iterateNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode>;
+}
+
+export interface NodesManagementService {
+    renameNode(nodeUid: string, newName: string, options: {
+        allowRenameRootNode: boolean,
+    }): Promise<DecryptedNode>;
+}