@protontech/drive-sdk 0.9.8 → 0.10.0

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

@@ -44,6 +44,10 @@ function generateAPIAlbumNode(linkOverrides = {}, overrides = {}) {
         ...node,
         Link: { ...node.Link, Type: 3, ...linkOverrides },
         Photo: null,
+        Album: {
+            PhotoCount: 1,
+            CoverLinkID: 'coverLinkId',
+        },
         Folder: null,
         ...overrides,
     };
@@ -103,6 +107,8 @@ describe('PhotosNodesAPIService', () => {
             const nodes = await Array.fromAsync(api.iterateNodes(['volumeId~nodeId'], 'volumeId'));
             expect(nodes).toHaveLength(1);
             expect(nodes[0].type).toBe(expectedType);
+
+            return nodes;
         }
 
         it('should convert folder (type 1) to folder node', async () => {
@@ -110,16 +116,16 @@ describe('PhotosNodesAPIService', () => {
         });
 
         it('should convert album (type 3) to album node', async () => {
-            await testIterateNodes(generateAPIAlbumNode(), NodeType.Album);
+            const nodes = await testIterateNodes(generateAPIAlbumNode(), NodeType.Album);
+
+            expect(nodes[0].album).toBeDefined();
+            expect(nodes[0].album?.photoCount).toEqual(1);
+            expect(nodes[0].album?.coverPhotoNodeUid).toBe('volumeId~coverLinkId');
         });
 
         it('should convert photo (type 2) to photo node with photo attributes', async () => {
-            apiMock.post = jest.fn().mockResolvedValue({ Links: [generateAPIPhotoNode()] });
-
-            const nodes = await Array.fromAsync(api.iterateNodes(['volumeId~nodeId'], 'volumeId'));
+            const nodes = await testIterateNodes(generateAPIPhotoNode(), NodeType.Photo);
 
-            expect(nodes).toHaveLength(1);
-            expect(nodes[0].type).toBe(NodeType.Photo);
             expect(nodes[0].photo).toBeDefined();
             expect(nodes[0].photo?.captureTime).toEqual(new Date(1700000000 * 1000));
             expect(nodes[0].photo?.tags).toEqual([1, 2]);
@@ -161,6 +167,10 @@ describe('PhotosNodesCache', () => {
                         },
                     ],
                 },
+                album: {
+                    photoCount: 1,
+                    coverPhotoNodeUid: 'volumeId~coverLinkId',
+                },
             });
 
             const node = cache.deserialiseNode(serialisedNode);
@@ -170,6 +180,9 @@ describe('PhotosNodesCache', () => {
             expect(node.photo?.captureTime).toEqual(new Date('2023-11-14T22:13:20.000Z'));
             expect(node.photo?.albums[0].additionTime).toBeInstanceOf(Date);
             expect(node.photo?.albums[0].additionTime).toEqual(new Date('2023-11-15T10:00:00.000Z'));
+            expect(node.album).toBeDefined();
+            expect(node.album?.photoCount).toEqual(1);
+            expect(node.album?.coverPhotoNodeUid).toBe('volumeId~coverLinkId');
         });
 
         it('should handle node without photo attributes', () => {
@@ -187,6 +200,7 @@ describe('PhotosNodesCache', () => {
             const node = cache.deserialiseNode(serialisedNode);
 
             expect(node.photo).toBeUndefined();
+            expect(node.album).toBeUndefined();
         });
     });
 });
@@ -244,6 +258,10 @@ describe('PhotosNodesAccess', () => {
                     tags: [1, 2],
                     albums: [],
                 },
+                album: {
+                    photoCount: 1,
+                    coverPhotoNodeUid: 'volumeId~coverLinkId',
+                },
             };
 
             // @ts-expect-error Accessing protected method for testing
@@ -253,6 +271,9 @@ describe('PhotosNodesAccess', () => {
             expect(parsedNode.photo).toBeDefined();
             expect(parsedNode.photo?.captureTime).toEqual(new Date('2023-11-14T22:13:20.000Z'));
             expect(parsedNode.photo?.tags).toEqual([1, 2]);
+            expect(parsedNode.album).toBeDefined();
+            expect(parsedNode.album?.photoCount).toEqual(1);
+            expect(parsedNode.album?.coverPhotoNodeUid).toBe('volumeId~coverLinkId');
         });
     });
 });

package/src/internal/photos/nodes.ts

@@ -75,11 +75,21 @@ export class PhotosNodesAPIService extends NodeAPIServiceBase<
             };
         }
 
-        if (link.Link.Type === 3) {
+        if (link.Link.Type === 3 && link.Album) {
             return {
                 ...baseNodeMetadata,
+                album: {
+                    photoCount: link.Album.PhotoCount,
+                    coverPhotoNodeUid: link.Album.CoverLinkID
+                        ? makeNodeUid(volumeId, link.Album.CoverLinkID)
+                        : undefined,
+                },
                 encryptedCrypto: {
                     ...baseCryptoNodeMetadata,
+                    folder: {
+                        armoredExtendedAttributes: link.Album.XAttr || undefined,
+                        armoredHashKey: link.Album.NodeHashKey as string,
+                    },
                 },
             };
         }
@@ -111,7 +121,8 @@ export class PhotosNodesCache extends NodesCacheBase<DecryptedPhotoNode> {
             typeof node !== 'object' ||
             (typeof node.photo !== 'object' && node.photo !== undefined) ||
             (typeof node.photo?.captureTime !== 'string' && node.folder?.captureTime !== undefined) ||
-            (typeof node.photo?.albums !== 'object' && node.photo?.albums !== undefined)
+            (typeof node.photo?.albums !== 'object' && node.photo?.albums !== undefined) ||
+            (typeof node.album !== 'object' && node.album !== undefined)
         ) {
             throw new Error(`Invalid node data: ${nodeData}`);
         }
@@ -190,6 +201,18 @@ export class PhotosNodesAccess extends NodesAccessBase<EncryptedPhotoNode, Decry
             };
         }
 
+        if (unparsedNode.type === NodeType.Album) {
+            const node = parseNodeBase(this.logger, {
+                ...unparsedNode,
+                type: NodeType.Folder,
+            });
+            return {
+                ...node,
+                album: unparsedNode.album,
+                type: NodeType.Album,
+            };
+        }
+
         return parseNodeBase(this.logger, unparsedNode);
     }
 }
@@ -210,6 +233,15 @@ export class PhotosNodesCryptoService extends NodesCryptoService {
             };
         }
 
+        if (decryptedNode.node.type === NodeType.Album) {
+            return {
+                node: {
+                    ...decryptedNode.node,
+                    album: encryptedNode.album,
+                },
+            };
+        }
+
         return decryptedNode;
     }
 }

package/src/internal/photos/timeline.ts

@@ -2,6 +2,7 @@ import { DriveCrypto } from '../../crypto';
 import { Logger } from '../../interface';
 import { makeNodeUid } from '../uids';
 import { PhotosAPIService } from './apiService';
+import { TimelineItem } from './interface';
 import { PhotosNodesAccess } from './nodes';
 import { PhotoSharesManager } from './shares';
 
@@ -23,11 +24,7 @@ export class PhotosTimeline {
         this.nodesService = nodesService;
     }
 
-    async *iterateTimeline(signal?: AbortSignal): AsyncGenerator<{
-        nodeUid: string;
-        captureTime: Date;
-        tags: number[];
-    }> {
+    async *iterateTimeline(signal?: AbortSignal): AsyncGenerator<TimelineItem> {
         const { volumeId } = await this.photoShares.getRootIDs();
         yield* this.apiService.iterateTimeline(volumeId, signal);
     }

package/src/internal/photos/upload.ts

@@ -141,7 +141,7 @@ export class PhotoUploadManager extends UploadManager {
 
     async commitDraftPhoto(
         nodeRevisionDraft: NodeRevisionDraft,
-        manifest: Uint8Array,
+        manifest: Uint8Array<ArrayBuffer>,
         extendedAttributes: {
             modificationTime?: Date;
             size: number;
@@ -185,7 +185,7 @@ export class PhotoUploadCryptoService extends UploadCryptoService {
         super(driveCrypto, nodesService);
     }
 
-    async generateContentHash(sha1: string, parentHashKey: Uint8Array): Promise<string> {
+    async generateContentHash(sha1: string, parentHashKey: Uint8Array<ArrayBuffer>): Promise<string> {
         return this.driveCrypto.generateLookupHash(sha1, parentHashKey);
     }
 }

package/src/internal/shares/apiService.ts

@@ -170,6 +170,7 @@ function convertSharePayload(response: GetShareResponse): EncryptedShare {
               }
             : undefined,
         type: convertShareTypeNumberToEnum(response.Type),
+        editorsCanShare: response.EditorsCanShare
     };
 }
 

package/src/internal/shares/interface.ts

@@ -78,6 +78,7 @@ export interface EncryptedShare extends BaseShare {
     creatorEmail: string;
     encryptedCrypto: EncryptedShareCrypto;
     membership?: ShareMembership;
+    editorsCanShare: boolean;
 }
 
 interface ShareMembership {

package/src/internal/sharing/apiService.ts

@@ -36,6 +36,9 @@ type GetSharedNodesResponse =
 type GetSharedWithMeNodesResponse =
     drivePaths['/drive/v2/sharedwithme']['get']['responses']['200']['content']['application/json'];
 
+type GetSharedAlbumsResponse =
+    drivePaths['/drive/photos/albums/shared-with-me']['get']['responses']['200']['content']['application/json'];
+
 type GetInvitationsResponse =
     drivePaths['/drive/v2/shares/invitations']['get']['responses']['200']['content']['application/json'];
 
@@ -61,8 +64,10 @@ type GetShareExternalInvitations =
 type GetShareMembers =
     drivePaths['/drive/v2/shares/{shareID}/members']['get']['responses']['200']['content']['application/json'];
 
-type PostSharedBookmarksRequest =
-    Extract<drivePaths['/drive/v2/urls/{token}/bookmark']['post']['requestBody'], {content: object}>['content']['application/json'];
+type PostSharedBookmarksRequest = Extract<
+    drivePaths['/drive/v2/urls/{token}/bookmark']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
 type PostSharedBookmarksResponse =
     drivePaths['/drive/v2/urls/{token}/bookmark']['post']['responses']['200']['content']['application/json'];
 
@@ -73,6 +78,14 @@ type PostCreateShareRequest = Extract<
 type PostCreateShareResponse =
     drivePaths['/drive/volumes/{volumeID}/shares']['post']['responses']['200']['content']['application/json'];
 
+type PostChangeSharePropertiesRequest = Extract<
+    drivePaths['/drive/shares/{shareID}/property']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+
+type PostChangeSharePropertiesResponse =
+    drivePaths['/drive/shares/{shareID}/property']['post']['responses']['200']['content']['application/json'];
+
 type PostInviteProtonUserRequest = Extract<
     drivePaths['/drive/v2/shares/{shareID}/invitations']['post']['requestBody'],
     { content: object }
@@ -184,6 +197,30 @@ export class SharingAPIService {
             }
             anchor = response.AnchorID;
         }
+
+        if (this.shareTargetTypes.includes(ShareTargetType.Album)) {
+            yield* this.iterateSharedAlbumUids(signal);
+        }
+    }
+
+    // TODO: Sharing cannot know about albums. We should remove this and use
+    // ShareTargetTypes when it is supported by the API.
+    private async *iterateSharedAlbumUids(signal?: AbortSignal): AsyncGenerator<string> {
+        let anchor = '';
+        while (true) {
+            const response = await this.apiService.get<GetSharedAlbumsResponse>(
+                `drive/photos/albums/shared-with-me?${anchor ? `AnchorID=${anchor}` : ''}`,
+                signal,
+            );
+            for (const album of response.Albums) {
+                yield makeNodeUid(album.VolumeID, album.LinkID);
+            }
+
+            if (!response.More || !response.AnchorID) {
+                break;
+            }
+            anchor = response.AnchorID;
+        }
     }
 
     async *iterateInvitationUids(signal?: AbortSignal): AsyncGenerator<string> {
@@ -304,7 +341,7 @@ export class SharingAPIService {
         addressId: string;
         addressKeyId: string;
     }): Promise<void> {
-         await this.apiService.post<PostSharedBookmarksRequest, PostSharedBookmarksResponse>(
+        await this.apiService.post<PostSharedBookmarksRequest, PostSharedBookmarksResponse>(
             `drive/v2/urls/${bookmark.token}/bookmark`,
             {
                 BookmarkShareURL: {
@@ -363,7 +400,7 @@ export class SharingAPIService {
             base64PassphraseKeyPacket: string;
             base64NameKeyPacket: string;
         },
-    ): Promise<string> {
+    ): Promise<{ shareId: string; editorsCanShare: boolean }> {
         const { volumeId, nodeId } = splitNodeUid(nodeUid);
         const response = await this.apiService.post<PostCreateShareRequest, PostCreateShareResponse>(
             `drive/volumes/${volumeId}/shares`,
@@ -378,13 +415,20 @@ export class SharingAPIService {
                 NameKeyPacket: node.base64NameKeyPacket,
             },
         );
-        return response.Share.ID;
+        return { shareId: response.Share.ID, editorsCanShare: response.Share.EditorsCanShare };
     }
 
     async deleteShare(shareId: string, force: boolean = false): Promise<void> {
         await this.apiService.delete(`drive/shares/${shareId}?Force=${force ? 1 : 0}`);
     }
 
+    async changeShareProperties(shareId: string, { editorsCanShare }: { editorsCanShare: boolean }) {
+        await this.apiService.post<PostChangeSharePropertiesRequest, PostChangeSharePropertiesResponse>(
+            `drive/shares/${shareId}/property`,
+            { EditorsCanShare: editorsCanShare },
+        );
+    }
+
     async inviteProtonUser(
         shareId: string,
         invitation: EncryptedInvitationRequest,

package/src/internal/sharing/cryptoService.ts

@@ -213,7 +213,7 @@ export class SharingCryptoService {
         } catch (error: unknown) {
             const message = getErrorMessage(error);
             const errorMessage = c('Error').t`Failed to decrypt item name: ${message}`;
-            nodeName = resultError(new Error(errorMessage));
+            nodeName = resultError(new Error(errorMessage, { cause: error }));
         }
 
         return {
@@ -458,7 +458,10 @@ export class SharingCryptoService {
             urlPassword = result.password;
             customPassword = resultOk(result.customPassword);
         } catch (originalError: unknown) {
-            const error = originalError instanceof Error ? originalError : new Error(c('Error').t`Unknown error`);
+            const error =
+                originalError instanceof Error
+                    ? originalError
+                    : new Error(c('Error').t`Unknown error`, { cause: originalError });
             return {
                 url: resultError(error),
                 customPassword: resultError(error),
@@ -473,7 +476,10 @@ export class SharingCryptoService {
         try {
             shareKey = await this.decryptBookmarkKey(encryptedBookmark, password);
         } catch (originalError: unknown) {
-            const error = originalError instanceof Error ? originalError : new Error(c('Error').t`Unknown error`);
+            const error =
+                originalError instanceof Error
+                    ? originalError
+                    : new Error(c('Error').t`Unknown error`, { cause: originalError });
             return {
                 url,
                 customPassword,
@@ -577,7 +583,7 @@ export class SharingCryptoService {
 
             const message = getErrorMessage(error);
             const errorMessage = c('Error').t`Failed to decrypt bookmark name: ${message}`;
-            return resultError(new Error(errorMessage));
+            return resultError(new Error(errorMessage, { cause: error }));
         }
     }
 }

package/src/internal/sharing/sharingManagement.test.ts

@@ -18,6 +18,8 @@ import { SharingManagement } from './sharingManagement';
 import { ValidationError } from '../../errors';
 import { ErrorCode } from '../apiService';
 
+const DEFAULT_SHARE_ID = 'shareId';
+
 describe('SharingManagement', () => {
     let logger: Logger;
     let apiService: SharingAPIService;
@@ -34,7 +36,7 @@ describe('SharingManagement', () => {
 
         // @ts-expect-error No need to implement all methods for mocking
         apiService = {
-            createStandardShare: jest.fn().mockReturnValue('newShareId'),
+            createStandardShare: jest.fn().mockReturnValue({ shareId: 'newShareId', editorsCanShare: false }),
             getShareInvitations: jest.fn().mockResolvedValue([]),
             getShareExternalInvitations: jest.fn().mockResolvedValue([]),
             getShareMembers: jest.fn().mockResolvedValue([]),
@@ -63,6 +65,7 @@ describe('SharingManagement', () => {
                 publicUrl: 'publicLinkUrl',
             }),
             updatePublicLink: jest.fn(),
+            changeShareProperties: jest.fn(),
         };
         // @ts-expect-error No need to implement all methods for mocking
         cache = {
@@ -98,7 +101,7 @@ describe('SharingManagement', () => {
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
             loadEncryptedShare: jest.fn().mockResolvedValue({
-                id: 'shareId',
+                id: DEFAULT_SHARE_ID,
                 addressId: 'addressId',
                 creatorEmail: 'address@example.com',
                 passphraseSessionKey: 'sharePassphraseSessionKey',
@@ -106,9 +109,11 @@ describe('SharingManagement', () => {
         };
         // @ts-expect-error No need to implement all methods for mocking
         nodesService = {
-            getNode: jest
-                .fn()
-                .mockImplementation((nodeUid) => ({ nodeUid, shareId: 'shareId', name: { ok: true, value: 'name' } })),
+            getNode: jest.fn().mockImplementation((nodeUid) => ({
+                nodeUid,
+                shareId: DEFAULT_SHARE_ID,
+                name: { ok: true, value: 'name' },
+            })),
             getNodeKeys: jest.fn().mockImplementation((nodeUid) => ({ key: 'node-key' })),
             getNodePrivateAndSessionKeys: jest.fn().mockImplementation((nodeUid) => ({})),
             getRootNodeEmailKey: jest.fn().mockResolvedValue({ email: 'volume-email', addressKey: 'volume-key' }),
@@ -225,6 +230,7 @@ describe('SharingManagement', () => {
                 nonProtonInvitations: [],
                 members: [],
                 publicLink: undefined,
+                editorsCanShare: false,
             });
             expect(apiService.updateInvitation).not.toHaveBeenCalled();
             expect(apiService.inviteProtonUser).toHaveBeenCalled();
@@ -395,6 +401,28 @@ describe('SharingManagement', () => {
                 expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
+            it('should update editorsCanChange', async () => {
+                const sharingInfo = await sharingManagement.shareNode(nodeUid, {
+                    editorsCanShare: true,
+                });
+
+                expect(sharingInfo).toEqual({
+                    protonInvitations: [
+                        {
+                            ...invitation,
+                            role: 'viewer',
+                        },
+                    ],
+                    nonProtonInvitations: [externalInvitation],
+                    members: [member],
+                    publicLink: undefined,
+                    editorsCanShare: true,
+                });
+                expect(apiService.changeShareProperties).toHaveBeenCalledWith(DEFAULT_SHARE_ID, {
+                    editorsCanShare: true,
+                });
+            });
+
             it('should be no-op if no change', async () => {
                 const sharingInfo = await sharingManagement.shareNode(nodeUid, {
                     users: [{ email: 'internal-email', role: MemberRole.Viewer }],

package/src/internal/sharing/sharingManagement.ts

@@ -77,11 +77,12 @@ export class SharingManagement {
             return;
         }
 
-        const [protonInvitations, nonProtonInvitations, members, publicLink] = await Promise.all([
+        const [protonInvitations, nonProtonInvitations, members, publicLink, share] = await Promise.all([
             Array.fromAsync(this.iterateShareInvitations(node.shareId)),
             Array.fromAsync(this.iterateShareExternalInvitations(node.shareId)),
             Array.fromAsync(this.iterateShareMembers(node.shareId)),
             this.getPublicLink(node.shareId),
+            this.sharesService.loadEncryptedShare(node.shareId),
         ]);
 
         return {
@@ -89,6 +90,7 @@ export class SharingManagement {
             nonProtonInvitations,
             members,
             publicLink,
+            editorsCanShare: share.editorsCanShare,
         };
     }
 
@@ -161,6 +163,7 @@ export class SharingManagement {
                     nonProtonInvitations: [],
                     members: [],
                     publicLink: undefined,
+                    editorsCanShare: result.editorsCanShare,
                 };
                 contextShareAddress = result.contextShareAddress;
             } catch (error: unknown) {
@@ -184,6 +187,11 @@ export class SharingManagement {
             contextShareAddress = await this.nodesService.getRootNodeEmailKey(nodeUid);
         }
 
+        if (settings.editorsCanShare !== undefined) {
+            await this.setEditorsCanShare(currentSharing.share.shareId, settings.editorsCanShare);
+            currentSharing.editorsCanShare = settings.editorsCanShare;
+        }
+
         const emailOptions: EmailOptions = {
             message: settings.emailOptions?.message,
             nodeName: settings.emailOptions?.includeNodeName ? currentSharing.nodeName : undefined,
@@ -294,6 +302,7 @@ export class SharingManagement {
             nonProtonInvitations: currentSharing.nonProtonInvitations,
             members: currentSharing.members,
             publicLink: currentSharing.publicLink,
+            editorsCanShare: currentSharing.editorsCanShare,
         };
     }
 
@@ -385,6 +394,7 @@ export class SharingManagement {
             nonProtonInvitations: currentSharing.nonProtonInvitations,
             members: currentSharing.members,
             publicLink: currentSharing.publicLink,
+            editorsCanShare: currentSharing.editorsCanShare,
         };
     }
 
@@ -415,7 +425,9 @@ export class SharingManagement {
         };
     }
 
-    private async createShare(nodeUid: string): Promise<{ share: Share; contextShareAddress: ContextShareAddress }> {
+    private async createShare(
+        nodeUid: string,
+    ): Promise<{ share: Share; contextShareAddress: ContextShareAddress; editorsCanShare: boolean }> {
         const node = await this.nodesService.getNode(nodeUid);
         if (!node.parentUid) {
             throw new ValidationError(c('Error').t`Cannot share root folder`);
@@ -426,10 +438,15 @@ export class SharingManagement {
 
         const nodeKeys = await this.nodesService.getNodePrivateAndSessionKeys(nodeUid);
         const keys = await this.cryptoService.generateShareKeys(nodeKeys, addressKey);
-        const shareId = await this.apiService.createStandardShare(nodeUid, addressId, keys.shareKey.encrypted, {
-            base64PassphraseKeyPacket: keys.base64PpassphraseKeyPacket,
-            base64NameKeyPacket: keys.base64NameKeyPacket,
-        });
+        const { shareId, editorsCanShare } = await this.apiService.createStandardShare(
+            nodeUid,
+            addressId,
+            keys.shareKey.encrypted,
+            {
+                base64PassphraseKeyPacket: keys.base64PpassphraseKeyPacket,
+                base64NameKeyPacket: keys.base64NameKeyPacket,
+            },
+        );
         await this.nodesService.notifyNodeChanged(nodeUid);
         if (await this.cache.hasSharedByMeNodeUidsLoaded()) {
             await this.cache.addSharedByMeNodeUid(nodeUid);
@@ -449,9 +466,14 @@ export class SharingManagement {
         return {
             share,
             contextShareAddress,
+            editorsCanShare,
         };
     }
 
+    private async setEditorsCanShare(shareId: string, editorsCanShare: boolean) {
+        await this.apiService.changeShareProperties(shareId, { editorsCanShare });
+    }
+
     /**
      * Deletes the share even if it is not empty.
      */

package/src/internal/sharingPublic/nodes.ts

@@ -18,7 +18,7 @@ import { SharingPublicSharesManager } from './shares';
 
 export class SharingPublicNodesCryptoService extends NodesCryptoService {
     async generateDocument(
-        parentKeys: { key: PrivateKey; hashKey: Uint8Array },
+        parentKeys: { key: PrivateKey; hashKey: Uint8Array<ArrayBuffer> },
         signingKeys: NodeSigningKeys,
         name: string,
     ) {

package/src/internal/upload/apiService.ts

@@ -142,7 +142,7 @@ export class UploadAPIService {
     }
 
     async getVerificationData(draftNodeRevisionUid: string): Promise<{
-        verificationCode: Uint8Array;
+        verificationCode: Uint8Array<ArrayBuffer>;
         base64ContentKeyPacket: string;
     }> {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(draftNodeRevisionUid);
@@ -162,14 +162,14 @@ export class UploadAPIService {
         blocks: {
             contentBlocks: {
                 index: number;
-                hash: Uint8Array;
+                hash: Uint8Array<ArrayBuffer>;
                 encryptedSize: number;
                 armoredSignature: string;
-                verificationToken: Uint8Array;
+                verificationToken: Uint8Array<ArrayBuffer>;
             }[];
             thumbnails?: {
                 type: ThumbnailType;
-                hash: Uint8Array;
+                hash: Uint8Array<ArrayBuffer>;
                 encryptedSize: number;
             }[];
         },
@@ -260,7 +260,7 @@ export class UploadAPIService {
     async uploadBlock(
         url: string,
         token: string,
-        block: Uint8Array,
+        block: Uint8Array<ArrayBuffer>,
         onProgress?: (uploadedBytes: number) => void,
         signal?: AbortSignal,
     ): Promise<void> {

package/src/internal/upload/blockVerifier.ts

@@ -3,7 +3,7 @@ import { UploadAPIService } from './apiService';
 import { UploadCryptoService } from './cryptoService';
 
 export class BlockVerifier {
-    private verificationCode?: Uint8Array;
+    private verificationCode?: Uint8Array<ArrayBuffer>;
     private contentKeyPacketSessionKey?: SessionKey;
 
     constructor(
@@ -26,8 +26,8 @@ export class BlockVerifier {
         );
     }
 
-    async verifyBlock(encryptedBlock: Uint8Array): Promise<{
-        verificationToken: Uint8Array;
+    async verifyBlock(encryptedBlock: Uint8Array<ArrayBuffer>): Promise<{
+        verificationToken: Uint8Array<ArrayBuffer>;
     }> {
         if (!this.verificationCode || !this.contentKeyPacketSessionKey) {
             throw new Error('Verifying block before loading verification data');