@protontech/drive-sdk 0.2.1 → 0.3.1

package/src/diagnostic/httpClient.ts

@@ -1,7 +1,7 @@
 import {
     ProtonDriveHTTPClient,
-    ProtonDriveHTTPClientBlobOptions,
-    ProtonDriveHTTPClientJsonOptions,
+    ProtonDriveHTTPClientBlobRequest,
+    ProtonDriveHTTPClientJsonRequest,
 } from '../interface';
 import { EventsGenerator } from './eventsGenerator';
 
@@ -19,7 +19,7 @@ export class DiagnosticHTTPClient extends EventsGenerator implements ProtonDrive
         this.httpClient = httpClient;
     }
 
-    async fetchJson(options: ProtonDriveHTTPClientJsonOptions): Promise<Response> {
+    async fetchJson(options: ProtonDriveHTTPClientJsonRequest): Promise<Response> {
         try {
             const response = await this.httpClient.fetchJson(options);
 
@@ -78,7 +78,7 @@ export class DiagnosticHTTPClient extends EventsGenerator implements ProtonDrive
         }
     }
 
-    fetchBlob(options: ProtonDriveHTTPClientBlobOptions): Promise<Response> {
+    fetchBlob(options: ProtonDriveHTTPClientBlobRequest): Promise<Response> {
         return this.httpClient.fetchBlob(options);
     }
 }

package/src/diagnostic/interface.ts

@@ -1,4 +1,4 @@
-import { DegradedNode, MaybeNode, MetricEvent } from '../interface';
+import { Author, MaybeNode, MetricEvent, NodeType, AnonymousUser } from '../interface';
 import { LogRecord } from '../telemetry';
 
 export interface Diagnostic {
@@ -67,77 +67,59 @@ export type HttpErrorResult = {
 // Event representing that node has some decryption or other (e.g., invalid name) issues.
 export type DegradedNodeResult = {
     type: 'degraded_node';
-    nodeUid: string;
-    node: DegradedNode;
-};
+} & NodeDetails;
 
 // Event representing that signature verification failing.
 export type UnverifiedAuthorResult = {
     type: 'unverified_author';
-    nodeUid: string;
-    revisionUid?: string;
     authorType: string;
-    claimedAuthor?: string;
+    claimedAuthor?: string | AnonymousUser;
     error: string;
-    node: MaybeNode;
-};
+} & NodeDetails;
 
 // Event representing that field from the extended attributes is not valid format.
 // Currently only `sha1` verification is supported.
 export type ExtendedAttributesErrorResult = {
     type: 'extended_attributes_error';
-    nodeUid: string;
-    revisionUid?: string;
     field: 'sha1';
     value: string;
-};
+} & NodeDetails;
 
 // Event representing that field from the extended attributes is missing.
 // Currently only `sha1` verification is supported.
 export type ExtendedAttributesMissingFieldResult = {
     type: 'extended_attributes_missing_field';
-    nodeUid: string;
-    revisionUid?: string;
     missingField: 'sha1';
-};
+} & NodeDetails;
 
 // Event representing that file is missing the active revision.
 export type ContentFileMissingRevisionResult = {
     type: 'content_file_missing_revision';
-    nodeUid: string;
-    revisionUid?: string;
-};
+} & NodeDetails;
 
 // Event representing that file content is not valid - either sha1 or size is not correct.
 export type ContentIntegrityErrorResult = {
     type: 'content_integrity_error';
-    nodeUid: string;
-    revisionUid?: string;
     claimedSha1?: string;
     computedSha1?: string;
     claimedSizeInBytes?: number;
     computedSizeInBytes?: number;
-};
+} & NodeDetails;
 
 // Event representing that downloading the file content failed.
 // This can be connection issue or server error. If its integrity issue,
 // it should be reported as `ContentIntegrityErrorResult`.
 export type ContentDownloadErrorResult = {
     type: 'content_download_error';
-    nodeUid: string;
-    revisionUid?: string;
     error: unknown;
-};
+} & NodeDetails;
 
 // Event representing that getting the thumbnails failed.
 // This can be connection issue or server error.
 export type ThumbnailsErrorResult = {
     type: 'thumbnails_error';
-    nodeUid: string;
-    revisionUid?: string;
-    message?: string;
-    error?: unknown;
-};
+    error: unknown;
+} & NodeDetails;
 
 // Event representing errors logged during the diagnostic.
 export type LogErrorResult = {
@@ -156,3 +138,19 @@ export type MetricResult = {
     type: 'metric';
     event: MetricEvent;
 };
+
+export type NodeDetails = {
+    safeNodeDetails: {
+        nodeUid: string;
+        revisionUid?: string;
+        nodeType: NodeType;
+        nodeCreationTime: Date;
+        keyAuthor: Author;
+        nameAuthor: Author;
+        errors: {
+            field: string;
+            error: unknown;
+        }[];
+    };
+    sensitiveNodeDetails: MaybeNode;
+};

package/src/diagnostic/sdkDiagnostic.ts

@@ -1,6 +1,6 @@
 import { Author, FileDownloader, MaybeNode, NodeType, Revision, ThumbnailType } from '../interface';
 import { ProtonDriveClient } from '../protonDriveClient';
-import { Diagnostic, DiagnosticOptions, DiagnosticResult } from './interface';
+import { Diagnostic, DiagnosticOptions, DiagnosticResult, NodeDetails } from './interface';
 import { IntegrityVerificationStream } from './integrityVerificationStream';
 
 /**
@@ -43,32 +43,19 @@ export class SDKDiagnostic implements Diagnostic {
     }
 
     private async *verifyNode(node: MaybeNode, options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
-        const nodeUid = node.ok ? node.value.uid : node.error.uid;
-
         if (!node.ok) {
             yield {
                 type: 'degraded_node',
-                nodeUid,
-                node: node.error,
+                ...getNodeDetails(node),
             };
         }
 
+        yield* this.verifyAuthor(node.ok ? node.value.keyAuthor : node.error.keyAuthor, 'key', node);
+        yield* this.verifyAuthor(node.ok ? node.value.nameAuthor : node.error.nameAuthor, 'name', node);
+
         const activeRevision = getActiveRevision(node);
-        const nodeInfo = {
-            ...getNodeUids(node),
-            node,
-        };
-
-        yield* this.verifyAuthor(node.ok ? node.value.keyAuthor : node.error.keyAuthor, {
-            ...nodeInfo,
-            authorType: 'key',
-        });
-        yield* this.verifyAuthor(node.ok ? node.value.nameAuthor : node.error.nameAuthor, {
-            ...nodeInfo,
-            authorType: 'name',
-        });
         if (activeRevision) {
-            yield* this.verifyAuthor(activeRevision.contentAuthor, { ...nodeInfo, authorType: 'content' });
+            yield* this.verifyAuthor(activeRevision.contentAuthor, 'content', node);
         }
 
         yield* this.verifyFileExtendedAttributes(node);
@@ -81,16 +68,14 @@ export class SDKDiagnostic implements Diagnostic {
         }
     }
 
-    private async *verifyAuthor(
-        author: Author,
-        info: { nodeUid: string; authorType: string; revisionUid?: string; node: MaybeNode },
-    ): AsyncGenerator<DiagnosticResult> {
+    private async *verifyAuthor(author: Author, authorType: string, node: MaybeNode): AsyncGenerator<DiagnosticResult> {
         if (!author.ok) {
             yield {
                 type: 'unverified_author',
+                authorType,
                 claimedAuthor: author.error.claimedAuthor,
                 error: author.error.error,
-                ...info,
+                ...getNodeDetails(node),
             };
         }
     }
@@ -104,17 +89,17 @@ export class SDKDiagnostic implements Diagnostic {
         if (claimedSha1 && !/^[0-9a-f]{40}$/i.test(claimedSha1)) {
             yield {
                 type: 'extended_attributes_error',
-                ...getNodeUids(node),
                 field: 'sha1',
                 value: claimedSha1,
+                ...getNodeDetails(node),
             };
         }
 
         if (expectedAttributes && !claimedSha1) {
             yield {
                 type: 'extended_attributes_missing_field',
-                ...getNodeUids(node),
                 missingField: 'sha1',
+                ...getNodeDetails(node),
             };
         }
     }
@@ -127,7 +112,7 @@ export class SDKDiagnostic implements Diagnostic {
         if (!activeRevision) {
             yield {
                 type: 'content_file_missing_revision',
-                nodeUid: node.ok ? node.value.uid : node.error.uid,
+                ...getNodeDetails(node),
             };
             return;
         }
@@ -158,18 +143,18 @@ export class SDKDiagnostic implements Diagnostic {
             if (claimedSha1 !== computedSha1 || claimedSizeInBytes !== computedSizeInBytes) {
                 yield {
                     type: 'content_integrity_error',
-                    ...getNodeUids(node),
                     claimedSha1,
                     computedSha1,
                     claimedSizeInBytes,
                     computedSizeInBytes,
+                    ...getNodeDetails(node),
                 };
             }
         } catch (error: unknown) {
             yield {
                 type: 'content_download_error',
-                ...getNodeUids(node),
                 error,
+                ...getNodeDetails(node),
             };
         }
     }
@@ -197,8 +182,8 @@ export class SDKDiagnostic implements Diagnostic {
             if (!result[0].ok && result[0].error !== 'Node has no thumbnail') {
                 yield {
                     type: 'thumbnails_error',
-                    nodeUid,
                     error: result[0].error,
+                    ...getNodeDetails(node),
                 };
             }
         } catch (error: unknown) {
@@ -226,6 +211,49 @@ export class SDKDiagnostic implements Diagnostic {
     }
 }
 
+function getNodeDetails(node: MaybeNode): NodeDetails {
+    const errors: {
+        field: string;
+        error: unknown;
+    }[] = [];
+
+    if (!node.ok) {
+        const degradedNode = node.error;
+        if (!degradedNode.name.ok) {
+            errors.push({
+                field: 'name',
+                error: degradedNode.name.error,
+            });
+        }
+        if (degradedNode.activeRevision?.ok === false) {
+            errors.push({
+                field: 'activeRevision',
+                error: degradedNode.activeRevision.error,
+            });
+        }
+        for (const error of degradedNode.errors ?? []) {
+            if (error instanceof Error) {
+                errors.push({
+                    field: 'error',
+                    error,
+                });
+            }
+        }
+    }
+
+    return {
+        safeNodeDetails: {
+            ...getNodeUids(node),
+            nodeType: getNodeType(node),
+            nodeCreationTime: node.ok ? node.value.creationTime : node.error.creationTime,
+            keyAuthor: node.ok ? node.value.keyAuthor : node.error.keyAuthor,
+            nameAuthor: node.ok ? node.value.nameAuthor : node.error.nameAuthor,
+            errors,
+        },
+        sensitiveNodeDetails: node,
+    };
+}
+
 function getNodeUids(node: MaybeNode): { nodeUid: string; revisionUid?: string } {
     const activeRevision = getActiveRevision(node);
     return {

package/src/errors.ts

@@ -70,17 +70,17 @@ export class ValidationError extends ProtonDriveError {
  * or choose another name. The available name is provided in the `availableName`
  * property (that will contain original name with the index that can be used).
  */
-export class NodeAlreadyExistsValidationError extends ValidationError {
-    name = 'NodeAlreadyExistsValidationError';
+export class NodeWithSameNameExistsValidationError extends ValidationError {
+    name = 'NodeWithSameNameExistsValidationError';
 
     public readonly existingNodeUid?: string;
 
-    public readonly ongoingUploadByOtherClient: boolean;
+    public readonly isUnfinishedUpload: boolean;
 
-    constructor(message: string, code: number, existingNodeUid?: string, ongoingUploadByOtherClient = false) {
+    constructor(message: string, code: number, existingNodeUid?: string, isUnfinishedUpload = false) {
         super(message, code);
         this.existingNodeUid = existingNodeUid;
-        this.ongoingUploadByOtherClient = ongoingUploadByOtherClient;
+        this.isUnfinishedUpload = isUnfinishedUpload;
     }
 }
 

package/src/interface/author.ts

@@ -24,6 +24,6 @@ export type AnonymousUser = null;
  * the claimed author and the verification error.
  */
 export type UnverifiedAuthorError = {
-    claimedAuthor?: string;
+    claimedAuthor?: string | AnonymousUser;
     error: string;
 };

package/src/interface/events.ts

@@ -20,13 +20,7 @@ export interface LatestEventIdProvider {
  */
 export type DriveListener = (event: DriveEvent) => Promise<void>;
 
-export type DriveEvent =
-    | NodeEvent
-    | FastForwardEvent
-    | TreeRefreshEvent
-    | TreeRemovalEvent
-    | FastForwardEvent
-    | SharedWithMeUpdated;
+export type DriveEvent = NodeEvent | FastForwardEvent | TreeRefreshEvent | TreeRemovalEvent | SharedWithMeUpdated;
 
 export type NodeEvent =
     | {

package/src/interface/httpClient.ts

@@ -1,18 +1,18 @@
 export interface ProtonDriveHTTPClient {
-    fetchJson(options: ProtonDriveHTTPClientJsonOptions): Promise<Response>;
-    fetchBlob(options: ProtonDriveHTTPClientBlobOptions): Promise<Response>;
+    fetchJson(request: ProtonDriveHTTPClientJsonRequest): Promise<Response>;
+    fetchBlob(request: ProtonDriveHTTPClientBlobRequest): Promise<Response>;
 }
 
-export type ProtonDriveHTTPClientJsonOptions = ProtonDriveHTTPClientBaseOptions & {
+export type ProtonDriveHTTPClientJsonRequest = ProtonDriveHTTPClientBaseRequest & {
     json?: object;
 };
 
-export type ProtonDriveHTTPClientBlobOptions = ProtonDriveHTTPClientBaseOptions & {
+export type ProtonDriveHTTPClientBlobRequest = ProtonDriveHTTPClientBaseRequest & {
     body?: XMLHttpRequestBodyInit;
     onProgress?: (progress: number) => void;
 };
 
-type ProtonDriveHTTPClientBaseOptions = {
+type ProtonDriveHTTPClientBaseRequest = {
     url: string;
     method: string;
     headers: Headers;

package/src/interface/index.ts

@@ -27,8 +27,8 @@ export type {
 export { DriveEventType, SDKEvent } from './events';
 export type {
     ProtonDriveHTTPClient,
-    ProtonDriveHTTPClientJsonOptions,
-    ProtonDriveHTTPClientBlobOptions,
+    ProtonDriveHTTPClientJsonRequest,
+    ProtonDriveHTTPClientBlobRequest,
 } from './httpClient';
 export type {
     MaybeNode,
@@ -89,10 +89,22 @@ export type ProtonDriveTelemetry = Telemetry<MetricEvent>;
 export type ProtonDriveEntitiesCache = ProtonDriveCache<string>;
 export type ProtonDriveCryptoCache = ProtonDriveCache<CachedCryptoMaterial>;
 export type CachedCryptoMaterial = {
-    passphrase?: string;
-    key: PrivateKey;
-    passphraseSessionKey: SessionKey;
-    hashKey?: Uint8Array;
+    nodeKeys?: {
+        // Passphrase should not be needed to keep, sessionKey should be enough.
+        // We will improve this in the future.
+        passphrase: string;
+        key: PrivateKey;
+        passphraseSessionKey: SessionKey;
+        contentKeyPacketSessionKey?: SessionKey;
+        hashKey?: Uint8Array;
+    };
+    shareKey?: {
+        key: PrivateKey;
+        passphraseSessionKey: SessionKey;
+    };
+    publicShareKey?: {
+        key: PrivateKey;
+    };
 };
 
 export interface ProtonDriveClientContructorParameters {

package/src/internal/apiService/apiService.ts

@@ -165,7 +165,7 @@ export class DriveAPIService {
             if (error instanceof ProtonDriveError) {
                 throw error;
             }
-            throw apiErrorFactory({ response });
+            throw apiErrorFactory({ response, error });
         }
     }
 
@@ -239,7 +239,11 @@ export class DriveAPIService {
             throw new AbortError(c('Error').t`Request aborted`);
         }
 
-        this.logger.debug(`${request.method} ${request.url}`);
+        if (attempt > 0) {
+            this.logger.debug(`${request.method} ${request.url}: retry ${attempt}`);
+        } else {
+            this.logger.debug(`${request.method} ${request.url}`);
+        }
 
         if (this.hasReachedServerErrorLimit) {
             this.logger.warn('Server errors limit reached');
@@ -250,6 +254,8 @@ export class DriveAPIService {
             throw new RateLimitedError(c('Error').t`Too many server requests, please try again later`);
         }
 
+        const start = Date.now();
+
         let response;
         try {
             response = await callback();
@@ -276,10 +282,13 @@ export class DriveAPIService {
             throw error;
         }
 
+        const end = Date.now();
+        const duration = end - start;
+
         if (response.ok) {
-            this.logger.info(`${request.method} ${request.url}: ${response.status}`);
+            this.logger.info(`${request.method} ${request.url}: ${response.status} (${duration}ms)`);
         } else {
-            this.logger.warn(`${request.method} ${request.url}: ${response.status}`);
+            this.logger.warn(`${request.method} ${request.url}: ${response.status} (${duration}ms)`);
         }
 
         if (response.status === HTTPErrorCode.TOO_MANY_REQUESTS) {

package/src/internal/apiService/errorCodes.ts

@@ -1,5 +1,6 @@
 export const enum HTTPErrorCode {
     OK = 200,
+    UNAUTHORIZED = 401,
     NOT_FOUND = 404,
     TOO_MANY_REQUESTS = 429,
     INTERNAL_SERVER_ERROR = 500,

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

@@ -62,7 +62,8 @@ describe('apiErrorFactory should return', () => {
     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');
+        expect(error.message).toBe('Not found');
+        expect((error as errors.NotFoundAPIError).code).toBe(ErrorCode.NOT_EXISTS);
     });
 });
 

package/src/internal/apiService/errors.ts

@@ -3,12 +3,23 @@ import { c } from 'ttag';
 import { ServerError, ValidationError } from '../../errors';
 import { ErrorCode, HTTPErrorCode } from './errorCodes';
 
-export function apiErrorFactory({ response, result }: { response: Response; result?: unknown }): ServerError {
+export function apiErrorFactory({
+    response,
+    result,
+    error,
+}: {
+    response: Response;
+    result?: unknown;
+    error?: 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 || c('Error').t`Unknown error`, response.status);
+        const fallbackMessage = error instanceof Error ? error.message : c('Error').t`Unknown error`;
+        const apiHttpError = new APIHTTPError(response.statusText || fallbackMessage, response.status);
+        apiHttpError.cause = error;
+        return apiHttpError;
     }
 
     const typedResult = result as {
@@ -40,7 +51,7 @@ export function apiErrorFactory({ response, result }: { response: Response; resu
 
     switch (code) {
         case ErrorCode.NOT_EXISTS:
-            return new NotFoundAPIError(message, code);
+            return new NotFoundAPIError(message, code, details);
         // 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
@@ -94,6 +105,6 @@ export class APICodeError extends ServerError {
     }
 }
 
-export class NotFoundAPIError extends APICodeError {
+export class NotFoundAPIError extends ValidationError {
     name = 'NotFoundAPIError';
 }

package/src/internal/events/index.ts

@@ -7,7 +7,7 @@ import { VolumeEventManager } from './volumeEventManager';
 import { EventManager } from './eventManager';
 import { SharesManager } from '../shares/manager';
 
-export type { DriveEvent, DriveListener } from './interface';
+export type { DriveEvent, DriveListener, EventSubscription } from './interface';
 export { DriveEventType } from './interface';
 
 const OWN_VOLUME_POLLING_INTERVAL = 30;

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

@@ -173,6 +173,34 @@ describe('nodeAPIService', () => {
         api = new NodeAPIService(getMockLogger(), apiMock);
     });
 
+    describe('getNode', () => {
+        it('should get node', async () => {
+            // @ts-expect-error Mocking for testing purposes
+            apiMock.post = jest.fn(async () =>
+                Promise.resolve({
+                    Links: [generateAPIFolderNode()],
+                }),
+            );
+
+            const node = await api.getNode('volumeId~nodeId', 'volumeId');
+
+            expect(node).toStrictEqual(generateFolderNode());
+        });
+
+        it('should throw error if node is not found', async () => {
+            // @ts-expect-error Mocking for testing purposes
+            apiMock.post = jest.fn(async () =>
+                Promise.resolve({
+                    Links: [],
+                }),
+            );
+
+            const promise = api.getNode('volumeId~nodeId', 'volumeId');
+
+            await expect(promise).rejects.toThrow('Node not found');
+        });
+    });
+
     describe('iterateNodes', () => {
         async function testIterateNodes(mockedLink: any, expectedNode: any, ownVolumeId = 'volumeId') {
             // @ts-expect-error Mocking for testing purposes

package/src/internal/nodes/apiService.ts

@@ -110,6 +110,9 @@ export class NodeAPIService {
     async getNode(nodeUid: string, ownVolumeId: string, signal?: AbortSignal): Promise<EncryptedNode> {
         const nodesGenerator = this.iterateNodes([nodeUid], ownVolumeId, signal);
         const result = await nodesGenerator.next();
+        if (!result.value) {
+            throw new ValidationError(c('Error').t`Node not found`);
+        }
         await nodesGenerator.return('finish');
         return result.value;
     }

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

@@ -18,10 +18,7 @@ describe('nodesCryptoCache', () => {
 
     beforeEach(async () => {
         memoryCache = new MemoryCache();
-        await memoryCache.setEntity('nodeKeys-missingPassphrase', {
-            key: 'privateKey',
-            sessionKey: 'sessionKey',
-        } as any);
+        await memoryCache.setEntity('nodeKeys-missingProperties', {} as any);
 
         cache = new NodesCryptoCache(getMockLogger(), memoryCache);
     });
@@ -96,14 +93,14 @@ describe('nodesCryptoCache', () => {
 
     it('should throw an error when retrieving a bad keys and remove the key', async () => {
         try {
-            await cache.getNodeKeys('missingPassphrase');
+            await cache.getNodeKeys('missingProperties');
             throw new Error('Should have thrown an error');
         } catch (error) {
-            expect(`${error}`).toBe('Error: Failed to deserialize node keys: missing passphrase');
+            expect(`${error}`).toBe('Error: Failed to deserialize node keys');
         }
 
         try {
-            await memoryCache.getEntity('nodeKeys-missingPassphrase');
+            await memoryCache.getEntity('nodeKeys-missingProperties');
             throw new Error('Should have thrown an error');
         } catch (error) {
             expect(`${error}`).toBe('Error: Entity not found');

package/src/internal/nodes/cryptoCache.ts

@@ -18,12 +18,14 @@ export class NodesCryptoCache {
 
     async setNodeKeys(nodeUid: string, keys: DecryptedNodeKeys): Promise<void> {
         const cacheUid = getCacheKey(nodeUid);
-        await this.driveCache.setEntity(cacheUid, keys);
+        await this.driveCache.setEntity(cacheUid, {
+            nodeKeys: keys,
+        });
     }
 
     async getNodeKeys(nodeUid: string): Promise<DecryptedNodeKeys> {
         const nodeKeysData = await this.driveCache.getEntity(getCacheKey(nodeUid));
-        if (!nodeKeysData.passphrase) {
+        if (!nodeKeysData.nodeKeys) {
             try {
                 await this.removeNodeKeys([nodeUid]);
             } catch (removingError: unknown) {
@@ -33,12 +35,9 @@ export class NodesCryptoCache {
                     `Failed to remove corrupted node keys from the cache: ${removingError instanceof Error ? removingError.message : removingError}`,
                 );
             }
-            throw new Error(`Failed to deserialize node keys: missing passphrase`);
+            throw new Error(`Failed to deserialize node keys`);
         }
-        return {
-            ...nodeKeysData,
-            passphrase: nodeKeysData.passphrase,
-        };
+        return nodeKeysData.nodeKeys;
     }
 
     async removeNodeKeys(nodeUids: string[]): Promise<void> {