@protontech/drive-sdk 0.9.9 → 0.10.0

package/src/crypto/interface.ts

@@ -2,6 +2,35 @@
 export interface PublicKey {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     readonly _idx: any;
+        readonly _keyContentHash: [string, string];
+
+    getVersion(): number;
+    getFingerprint(): string;
+    getSHA256Fingerprints(): string[];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getKeyID(): any;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getKeyIDs(): any[];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getAlgorithmInfo(): any;
+    getCreationTime(): Date;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    isPrivate: any;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    isPrivateKeyV4: any;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    isPrivateKeyV6: any;
+    getExpirationTime(): Date | number | null;
+    getUserIDs(): string[];
+    isWeak(): boolean;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    equals(otherKey: any, ignoreOtherCerts?: boolean): boolean;
+    subkeys: {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        getAlgorithmInfo(): any;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        getKeyID(): any;
+    }[];
 }
 
 export interface PrivateKey extends PublicKey {
@@ -9,7 +38,9 @@ export interface PrivateKey extends PublicKey {
 }
 
 export interface SessionKey {
-    data: Uint8Array;
+    data: Uint8Array<ArrayBuffer>;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    algorithm: any;
 }
 
 export enum VERIFICATION_STATUS {
@@ -66,14 +97,14 @@ export interface OpenPGPCrypto {
         sessionKey: SessionKey,
         encryptionKeys: PublicKey | PublicKey[],
     ) => Promise<{
-        keyPacket: Uint8Array;
+        keyPacket: Uint8Array<ArrayBuffer>;
     }>;
 
     encryptSessionKeyWithPassword: (
         sessionKey: SessionKey,
         password: string,
     ) => Promise<{
-        keyPacket: Uint8Array;
+        keyPacket: Uint8Array<ArrayBuffer>;
     }>;
 
     /**
@@ -87,7 +118,7 @@ export interface OpenPGPCrypto {
     }>;
 
     encryptArmored: (
-        data: Uint8Array,
+        data: Uint8Array<ArrayBuffer>,
         encryptionKeys: PublicKey[],
         sessionKey?: SessionKey,
     ) => Promise<{
@@ -95,16 +126,16 @@ export interface OpenPGPCrypto {
     }>;
 
     encryptAndSign: (
-        data: Uint8Array,
+        data: Uint8Array<ArrayBuffer>,
         sessionKey: SessionKey,
         encryptionKeys: PublicKey[],
         signingKey: PrivateKey,
     ) => Promise<{
-        encryptedData: Uint8Array;
+        encryptedData: Uint8Array<ArrayBuffer>;
     }>;
 
     encryptAndSignArmored: (
-        data: Uint8Array,
+        data: Uint8Array<ArrayBuffer>,
         sessionKey: SessionKey | undefined,
         encryptionKeys: PublicKey[],
         signingKey: PrivateKey,
@@ -114,17 +145,17 @@ export interface OpenPGPCrypto {
     }>;
 
     encryptAndSignDetached: (
-        data: Uint8Array,
+        data: Uint8Array<ArrayBuffer>,
         sessionKey: SessionKey,
         encryptionKeys: PublicKey[],
         signingKey: PrivateKey,
     ) => Promise<{
-        encryptedData: Uint8Array;
-        signature: Uint8Array;
+        encryptedData: Uint8Array<ArrayBuffer>;
+        signature: Uint8Array<ArrayBuffer>;
     }>;
 
     encryptAndSignDetachedArmored: (
-        data: Uint8Array,
+        data: Uint8Array<ArrayBuffer>,
         sessionKey: SessionKey,
         encryptionKeys: PublicKey[],
         signingKey: PrivateKey,
@@ -134,23 +165,23 @@ export interface OpenPGPCrypto {
     }>;
 
     sign: (
-        data: Uint8Array,
+        data: Uint8Array<ArrayBuffer>,
         signingKey: PrivateKey,
         signatureContext: string,
     ) => Promise<{
-        signature: Uint8Array;
+        signature: Uint8Array<ArrayBuffer>;
     }>;
 
     signArmored: (
-        data: Uint8Array,
+        data: Uint8Array<ArrayBuffer>,
         signingKey: PrivateKey | PrivateKey[],
     ) => Promise<{
         signature: string;
     }>;
 
     verify: (
-        data: Uint8Array,
-        signature: Uint8Array,
+        data: Uint8Array<ArrayBuffer>,
+        signature: Uint8Array<ArrayBuffer>,
         verificationKeys: PublicKey | PublicKey[],
     ) => Promise<{
         verified: VERIFICATION_STATUS;
@@ -158,7 +189,7 @@ export interface OpenPGPCrypto {
     }>;
 
     verifyArmored: (
-        data: Uint8Array,
+        data: Uint8Array<ArrayBuffer>,
         armoredSignature: string,
         verificationKeys: PublicKey | PublicKey[],
         signatureContext?: string,
@@ -167,41 +198,41 @@ export interface OpenPGPCrypto {
         verificationErrors?: Error[];
     }>;
 
-    decryptSessionKey: (data: Uint8Array, decryptionKeys: PrivateKey | PrivateKey[]) => Promise<SessionKey>;
+    decryptSessionKey: (data: Uint8Array<ArrayBuffer>, decryptionKeys: PrivateKey | PrivateKey[]) => Promise<SessionKey>;
 
     decryptArmoredSessionKey: (armoredData: string, decryptionKeys: PrivateKey | PrivateKey[]) => Promise<SessionKey>;
 
     decryptKey: (armoredKey: string, passphrase: string) => Promise<PrivateKey>;
 
     decryptAndVerify(
-        data: Uint8Array,
+        data: Uint8Array<ArrayBuffer>,
         sessionKey: SessionKey,
         verificationKeys: PublicKey | PublicKey[],
     ): Promise<{
-        data: Uint8Array;
+        data: Uint8Array<ArrayBuffer>;
         verified: VERIFICATION_STATUS;
         verificationErrors?: Error[];
     }>;
 
     decryptAndVerifyDetached(
-        data: Uint8Array,
-        signature: Uint8Array | undefined,
+        data: Uint8Array<ArrayBuffer>,
+        signature: Uint8Array<ArrayBuffer> | undefined,
         sessionKey: SessionKey,
         verificationKeys?: PublicKey | PublicKey[],
     ): Promise<{
-        data: Uint8Array;
+        data: Uint8Array<ArrayBuffer>;
         verified: VERIFICATION_STATUS;
         verificationErrors?: Error[];
     }>;
 
-    decryptArmored(armoredData: string, decryptionKeys: PrivateKey | PrivateKey[]): Promise<Uint8Array>;
+    decryptArmored(armoredData: string, decryptionKeys: PrivateKey | PrivateKey[]): Promise<Uint8Array<ArrayBuffer>>;
 
     decryptArmoredAndVerify: (
         armoredData: string,
         decryptionKeys: PrivateKey | PrivateKey[],
         verificationKeys: PublicKey | PublicKey[],
     ) => Promise<{
-        data: Uint8Array;
+        data: Uint8Array<ArrayBuffer>;
         verified: VERIFICATION_STATUS;
         verificationErrors?: Error[];
     }>;
@@ -212,10 +243,10 @@ export interface OpenPGPCrypto {
         sessionKey: SessionKey,
         verificationKeys: PublicKey | PublicKey[],
     ) => Promise<{
-        data: Uint8Array;
+        data: Uint8Array<ArrayBuffer>;
         verified: VERIFICATION_STATUS;
         verificationErrors?: Error[];
     }>;
 
-    decryptArmoredWithPassword(armoredData: string, password: string): Promise<Uint8Array>;
+    decryptArmoredWithPassword(armoredData: string, password: string): Promise<Uint8Array<ArrayBuffer>>;
 }

package/src/crypto/openPGPCrypto.ts

@@ -18,15 +18,15 @@ export interface OpenPGPCryptoProxy {
             encryptionKeys?: PublicKey | PublicKey[];
             passwords?: string[];
         },
-    ) => Promise<Uint8Array>;
+    ) => Promise<Uint8Array<ArrayBuffer>>;
     decryptSessionKey: (options: {
         armoredMessage?: string;
-        binaryMessage?: Uint8Array;
+        binaryMessage?: Uint8Array<ArrayBuffer>;
         decryptionKeys: PrivateKey | PrivateKey[];
     }) => Promise<SessionKey | undefined>;
     encryptMessage: <Format extends 'armored' | 'binary' = 'armored', Detached extends boolean = false>(options: {
         format?: Format;
-        binaryData: Uint8Array;
+        binaryData: Uint8Array<ArrayBuffer>;
         sessionKey?: SessionKey;
         encryptionKeys: PublicKey[];
         signingKeys?: PrivateKey;
@@ -35,39 +35,39 @@ export interface OpenPGPCryptoProxy {
     }) => Promise<
         Detached extends true
             ? {
-                  message: Format extends 'binary' ? Uint8Array : string;
-                  signature: Format extends 'binary' ? Uint8Array : string;
+                  message: Format extends 'binary' ? Uint8Array<ArrayBuffer> : string;
+                  signature: Format extends 'binary' ? Uint8Array<ArrayBuffer> : string;
               }
             : {
-                  message: Format extends 'binary' ? Uint8Array : string;
+                  message: Format extends 'binary' ? Uint8Array<ArrayBuffer> : string;
               }
     >;
     decryptMessage: <Format extends 'utf8' | 'binary' = 'utf8'>(options: {
         format: Format;
         armoredMessage?: string;
-        binaryMessage?: Uint8Array;
+        binaryMessage?: Uint8Array<ArrayBuffer>;
         armoredSignature?: string;
-        binarySignature?: Uint8Array;
+        binarySignature?: Uint8Array<ArrayBuffer>;
         sessionKeys?: SessionKey;
         passwords?: string[];
         decryptionKeys?: PrivateKey | PrivateKey[];
         verificationKeys?: PublicKey | PublicKey[];
     }) => Promise<{
-        data: Format extends 'binary' ? Uint8Array : string;
+        data: Format extends 'binary' ? Uint8Array<ArrayBuffer> : string;
         verificationStatus: VERIFICATION_STATUS;
         verificationErrors?: Error[];
     }>;
     signMessage: <Format extends 'binary' | 'armored' = 'armored'>(options: {
         format: Format;
-        binaryData: Uint8Array;
+        binaryData: Uint8Array<ArrayBuffer>;
         signingKeys: PrivateKey | PrivateKey[];
         detached: boolean;
         signatureContext?: { critical: boolean; value: string };
-    }) => Promise<Format extends 'binary' ? Uint8Array : string>;
+    }) => Promise<Format extends 'binary' ? Uint8Array<ArrayBuffer> : string>;
     verifyMessage: (options: {
-        binaryData: Uint8Array;
+        binaryData: Uint8Array<ArrayBuffer>;
         armoredSignature?: string;
-        binarySignature?: Uint8Array;
+        binarySignature?: Uint8Array<ArrayBuffer>;
         verificationKeys: PublicKey | PublicKey[];
         signatureContext?: { critical: boolean; value: string };
     }) => Promise<{
@@ -137,7 +137,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         };
     }
 
-    async encryptArmored(data: Uint8Array, encryptionKeys: PublicKey[], sessionKey?: SessionKey) {
+    async encryptArmored(data: Uint8Array<ArrayBuffer>, encryptionKeys: PublicKey[], sessionKey?: SessionKey) {
         const { message: armoredData } = await this.cryptoProxy.encryptMessage({
             binaryData: data,
             sessionKey,
@@ -149,7 +149,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
     }
 
     async encryptAndSign(
-        data: Uint8Array,
+        data: Uint8Array<ArrayBuffer>,
         sessionKey: SessionKey,
         encryptionKeys: PublicKey[],
         signingKey: PrivateKey,
@@ -168,7 +168,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
     }
 
     async encryptAndSignArmored(
-        data: Uint8Array,
+        data: Uint8Array<ArrayBuffer>,
         sessionKey: SessionKey | undefined,
         encryptionKeys: PublicKey[],
         signingKey: PrivateKey,
@@ -188,7 +188,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
     }
 
     async encryptAndSignDetached(
-        data: Uint8Array,
+        data: Uint8Array<ArrayBuffer>,
         sessionKey: SessionKey,
         encryptionKeys: PublicKey[],
         signingKey: PrivateKey,
@@ -208,7 +208,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
     }
 
     async encryptAndSignDetachedArmored(
-        data: Uint8Array,
+        data: Uint8Array<ArrayBuffer>,
         sessionKey: SessionKey,
         encryptionKeys: PublicKey[],
         signingKey: PrivateKey,
@@ -226,7 +226,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         };
     }
 
-    async sign(data: Uint8Array, signingKeys: PrivateKey | PrivateKey[], signatureContext: string) {
+    async sign(data: Uint8Array<ArrayBuffer>, signingKeys: PrivateKey | PrivateKey[], signatureContext: string) {
         const signature = await this.cryptoProxy.signMessage({
             binaryData: data,
             signingKeys,
@@ -239,7 +239,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         };
     }
 
-    async signArmored(data: Uint8Array, signingKeys: PrivateKey | PrivateKey[]) {
+    async signArmored(data: Uint8Array<ArrayBuffer>, signingKeys: PrivateKey | PrivateKey[]) {
         const signature = await this.cryptoProxy.signMessage({
             binaryData: data,
             signingKeys,
@@ -251,7 +251,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         };
     }
 
-    async verify(data: Uint8Array, signature: Uint8Array, verificationKeys: PublicKey | PublicKey[]) {
+    async verify(data: Uint8Array<ArrayBuffer>, signature: Uint8Array<ArrayBuffer>, verificationKeys: PublicKey | PublicKey[]) {
         const { verificationStatus, errors } = await this.cryptoProxy.verifyMessage({
             binaryData: data,
             binarySignature: signature,
@@ -264,7 +264,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
     }
 
     async verifyArmored(
-        data: Uint8Array,
+        data: Uint8Array<ArrayBuffer>,
         armoredSignature: string,
         verificationKeys: PublicKey | PublicKey[],
         signatureContext?: string,
@@ -282,7 +282,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         };
     }
 
-    async decryptSessionKey(data: Uint8Array, decryptionKeys: PrivateKey | PrivateKey[]) {
+    async decryptSessionKey(data: Uint8Array<ArrayBuffer>, decryptionKeys: PrivateKey | PrivateKey[]) {
         const sessionKey = await this.cryptoProxy.decryptSessionKey({
             binaryMessage: data,
             decryptionKeys,
@@ -316,7 +316,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         return key;
     }
 
-    async decryptAndVerify(data: Uint8Array, sessionKey: SessionKey, verificationKeys: PublicKey[]) {
+    async decryptAndVerify(data: Uint8Array<ArrayBuffer>, sessionKey: SessionKey, verificationKeys: PublicKey[]) {
         const {
             data: decryptedData,
             verificationStatus,
@@ -336,8 +336,8 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
     }
 
     async decryptAndVerifyDetached(
-        data: Uint8Array,
-        signature: Uint8Array | undefined,
+        data: Uint8Array<ArrayBuffer>,
+        signature: Uint8Array<ArrayBuffer> | undefined,
         sessionKey: SessionKey,
         verificationKeys?: PublicKey[],
     ) {

package/src/interface/index.ts

@@ -43,11 +43,19 @@ export type {
     NodeOrUid,
     RevisionOrUid,
     NodeResult,
+    NodeResultWithError,
     NodeResultWithNewUid,
     Membership,
 } from './nodes';
 export { NodeType, MemberRole, RevisionState } from './nodes';
-export type { MaybePhotoNode, MaybeMissingPhotoNode, PhotoNode, DegradedPhotoNode, PhotoAttributes } from './photos';
+export type {
+    MaybePhotoNode,
+    MaybeMissingPhotoNode,
+    PhotoNode,
+    DegradedPhotoNode,
+    PhotoAttributes,
+    AlbumAttributes,
+} from './photos';
 export type {
     ProtonInvitation,
     ProtonInvitationWithNode,
@@ -100,7 +108,7 @@ export type CachedCryptoMaterial = {
         key: PrivateKey;
         passphraseSessionKey: SessionKey;
         contentKeyPacketSessionKey?: SessionKey;
-        hashKey?: Uint8Array;
+        hashKey?: Uint8Array<ArrayBuffer>;
     };
     shareKey?: {
         key: PrivateKey;

package/src/interface/nodes.ts

@@ -229,4 +229,5 @@ export type RevisionOrUid = Revision | string;
 
 // TODO: Remove string from the result and use Error instead to be compatible with the NodeResultWithNewUid.
 export type NodeResult = { uid: string; ok: true } | { uid: string; ok: false; error: string };
+export type NodeResultWithError = { uid: string; ok: true } | { uid: string; ok: false; error: Error };
 export type NodeResultWithNewUid = { uid: string; newUid: string; ok: true } | { uid: string; ok: false; error: Error };

package/src/interface/photos.ts

@@ -21,8 +21,9 @@ export type MaybeMissingPhotoNode = Result<PhotoNode, DegradedPhotoNode | Missin
  * See `NodeEntity` for more information.
  */
 export type PhotoNode = NodeEntity & {
-    type: NodeType.Photo;
+    type: NodeType.Photo | NodeType.Album;
     photo?: PhotoAttributes;
+    album?: AlbumAttributes;
 };
 
 /**
@@ -32,6 +33,7 @@ export type PhotoNode = NodeEntity & {
  */
 export type DegradedPhotoNode = DegradedNode & {
     photo?: PhotoAttributes;
+    album?: AlbumAttributes;
 };
 
 /**
@@ -65,3 +67,19 @@ export type PhotoAttributes = {
      */
     tags: number[]; // TODO: enum
 }
+
+/**
+ * Attributes of an album.
+ *
+ * Only nodes of type `NodeType.Album` have property of this type.
+ */
+export type AlbumAttributes = {
+    /**
+     * Number of photos in the album.
+     */
+    photoCount: number;
+    /**
+     * UID of the cover photo node of the album.
+     */
+    coverPhotoNodeUid?: string;
+}

package/src/interface/sharing.ts

@@ -85,6 +85,7 @@ export type ShareNodeSettings = {
         message?: string;
         includeNodeName?: boolean;
     };
+    editorsCanShare?: boolean;
 };
 
 export type ShareMembersSettings =
@@ -107,6 +108,7 @@ export type ShareResult = {
     nonProtonInvitations: NonProtonInvitation[];
     members: Member[];
     publicLink?: PublicLink;
+    editorsCanShare: boolean;
 };
 
 export type UnshareNodeSettings = {

package/src/interface/telemetry.ts

@@ -24,6 +24,7 @@ export interface MetricAPIRetrySucceededEvent {
     eventName: 'apiRetrySucceeded';
     url: string;
     failedAttempts: number;
+    previousError?: unknown;
 }
 
 export interface MetricDebounceLongWaitEvent {

package/src/interface/thumbnail.ts

@@ -1,6 +1,6 @@
 export type Thumbnail = {
     type: ThumbnailType;
-    thumbnail: Uint8Array;
+    thumbnail: Uint8Array<ArrayBuffer>;
 };
 
 export enum ThumbnailType {
@@ -9,5 +9,5 @@ export enum ThumbnailType {
 }
 
 export type ThumbnailResult =
-    | { nodeUid: string; ok: true; thumbnail: Uint8Array }
+    | { nodeUid: string; ok: true; thumbnail: Uint8Array<ArrayBuffer> }
     | { nodeUid: string; ok: false; error: string };