@binsky/passman-client-ts 0.1.10 → 0.2.1

package/lib/Model/Credential.js

@@ -9,22 +9,46 @@ class Credential {
     vault;
     server;
     ENCRYPTED_FIELDS = ['description', 'username', 'password', 'files', 'custom_fields', 'otp', 'email', 'tags', 'url', 'compromised', 'shared_key'];
+    /**
+     * Contains all ENCRYPTED_FIELDS that matches to one of the types: string|number|boolean|null
+     */
+    SERIALIZABLE_ENCRYPTED_FIELDS = ['description', 'username', 'password', 'email', 'url', 'compromised', 'shared_key'];
+    /**
+     * encryptedData & spacialServerUpdateFields needs to be merged in order to save to credential to the server (api)
+     * @protected
+     */
     encryptedData;
+    /**
+     * Should not be overwritten/cleared during Credential instance lifetime, since it contains acl data managed by ShareService.
+     * @protected
+     */
+    _spacialServerUpdateFields;
+    /**
+     * This is always set if the credential is shared with us.
+     *
+     * The sharedCredentialEncryptionKey is encrypted with the vault key and injected by ShareService.
+     * To be able to hold this credential instance in an (initial, fully) unencrypted state (needed to fetch the full vault without vault key given),
+     * we need to split the encrypted and unencrypted shared credential encryption keys.
+     */
+    encryptedSharedCredentialEncryptionKey;
+    sharedCredentialEncryptionKey;
     decryptedDataCache;
-    sharedCredentialEncryptionKey; // this is set if the credential is shared with us (injected by ShareService)
     foundUnspecifiedEncryptionError = false;
+    decryptedDataCacheName;
     // can be used to re-encrypt credential data, if the original vault key is not changed yet
     overwriteVaultKey = undefined;
     constructor(vault, server, encryptedData = undefined) {
         this.vault = vault;
         this.server = server;
         this.encryptedData = encryptedData;
+        this._spacialServerUpdateFields = {};
         this.decryptedDataCache = {};
         if (encryptedData === undefined) {
             this.encryptedData = {};
             this.initializeAllFields();
         }
         this.vault_id = vault.vaultId;
+        this.decryptedDataCacheName = this.getVaultGuid() + '_' + this.guid;
     }
     initializeAllFields() {
         this.user_id = null;
@@ -57,50 +81,67 @@ class Credential {
      * The current credential object will be updated with the server response data if possible.
      */
     async save() {
-        let credentialResponse = await this.server.postJson('/credentials', this.encryptedData, (response) => {
+        let requestData = { ...this.encryptedData, ...this._spacialServerUpdateFields };
+        let credentialResponse = await this.server.postJson('/credentials', requestData, (response) => {
             this.server.logger.onError(response.message);
         });
         if (credentialResponse) {
             this.encryptedData = credentialResponse;
             this.decryptedDataCache = {};
+            this.tags.forEach(value => value.text && this.vault.collectedTags.add(value.text));
         }
         return credentialResponse;
     }
     /**
      * Update / edit an existing credential on the server.
      * The current credential object will be updated with the server response data if possible.
+     * This will not touch the virtual acl field.
      */
     async update() {
         if (this.acl === undefined || this.acl.permissions.hasPermission(SharingACL_1.SharingACL.permissions.WRITE)) {
-            let credentialResponse = await this.server.postJson('/credentials/' + this.guid, this.encryptedData, (response) => {
+            let requestData = { ...this.encryptedData, ...this._spacialServerUpdateFields };
+            let credentialResponse = await this.server.postJson('/credentials/' + this.guid, requestData, (response) => {
                 this.server.logger.onError(response.message);
             }, 'PATCH');
             if (credentialResponse) {
-                if (this.encryptedData.acl) {
-                    credentialResponse.acl = this.encryptedData.acl;
-                }
                 this.encryptedData = credentialResponse;
                 this.decryptedDataCache = {};
+                if (Array.isArray(this.tags)) {
+                    this.tags.forEach(value => value?.text && this.vault.collectedTags.add(value.text));
+                }
+                else {
+                    // recover correct tags structure
+                    this.tags = [];
+                }
             }
             return credentialResponse;
         }
     }
     /**
      * Refresh the local credential data based on the server, using the credentials guid.
-     * It is not supported to do that for credentials, shared with us.
+     * It is not supported to do that for credentials, shared with us. (Therefore this will not touch the virtual acl field.)
      */
     async refresh() {
-        if (this.sharedCredentialEncryptionKey) {
+        if (this.encryptedSharedCredentialEncryptionKey) {
             // credential is shared with us
-            // no credential refresh possible, since there is no backend api to do that
+            // no credential refresh possible, since there is no backend api to do that for a specific shared credential
+            // if it will be implemented in the future, don't forget to update the acl field, that's currently injected by ShareService
         }
         else {
+            this.clearDecryptedDataCache(true);
             let credentialResponse = await this.server.getJson('/credentials/' + this.guid, (response) => {
                 this.server.logger.onError(response.message);
             });
             if (credentialResponse) {
                 this.encryptedData = credentialResponse;
                 this.decryptedDataCache = {};
+                if (Array.isArray(this.tags)) {
+                    this.tags.forEach(value => value?.text && this.vault.collectedTags.add(value.text));
+                }
+                else {
+                    // recover correct tags structure
+                    this.tags = [];
+                }
             }
             return credentialResponse;
         }
@@ -110,6 +151,7 @@ class Credential {
      */
     async destroy() {
         if (this.acl === undefined || this.acl.permissions.hasPermission(SharingACL_1.SharingACL.permissions.WRITE)) {
+            this.clearDecryptedDataCache(true);
             let credentialResponse = await this.server.deleteJson('/credentials/' + this.guid, (response) => {
                 this.server.logger.onError(response.message);
             });
@@ -118,8 +160,38 @@ class Credential {
             return credentialResponse;
         }
     }
-    clearDecryptedDataCache() {
+    /**
+     * This is the correct function to "lock" the credential (to be called subsequently when the vault got locked).
+     * It clears the decrypted credential data cache as well as a potential sharedCredentialEncryptionKey.
+     * This will not clear the serialized decrypted data cache, managed by the used DecryptedDataCachingHandlerInterface implementation.
+     * Set clearCachingHandlerManagedDecryptedData=true to do so (by calling getDecryptedDataCacheHandler().clearCacheByName('...'))
+     */
+    clearDecryptedDataCache(clearCachingHandlerManagedDecryptedData = false) {
         this.decryptedDataCache = {};
+        this.sharedCredentialEncryptionKey = undefined;
+        if (clearCachingHandlerManagedDecryptedData) {
+            // atm. we are not interested in the result, so we keep the returned Promise running in background
+            this.server.persistence.getDecryptedDataCacheHandler().clearCacheByName(this.decryptedDataCacheName);
+        }
+    }
+    /**
+     * Restore only serializable fields of the CredentialInterface.
+     */
+    async restoreSerializedDecryptedDataCache() {
+        const cacheHandler = this.server.persistence.getDecryptedDataCacheHandler();
+        for (const propertyName of this.SERIALIZABLE_ENCRYPTED_FIELDS) {
+            this.decryptedDataCache[propertyName] = await cacheHandler?.get(this.decryptedDataCacheName, propertyName);
+        }
+    }
+    /**
+     * Update or delete an entry in the decrypted data cache.
+     * @param propertyName
+     * @param deleteFromCache
+     */
+    updateSerializedDecryptedDataCacheEntry(propertyName, deleteFromCache = false) {
+        if (this.SERIALIZABLE_ENCRYPTED_FIELDS.includes(propertyName) && this.server.persistence.getDecryptedDataCacheHandler()) {
+            return this.server.persistence.getDecryptedDataCacheHandler().set(this.decryptedDataCacheName, propertyName, deleteFromCache ? undefined : this.decryptedDataCache[propertyName]);
+        }
     }
     /**
      * Create a credential object based on its encrypted data.
@@ -127,7 +199,7 @@ class Credential {
      * @param vault
      * @param server
      */
-    static async fromData(data, vault, server) {
+    static fromData(data, vault, server) {
         return new Credential(vault, server, data);
     }
     /**
@@ -142,6 +214,17 @@ class Credential {
         await cred.refresh();
         return cred;
     }
+    static fromSerializable(serialized, vault, server) {
+        const credential = new Credential(vault, server, serialized.encryptedData);
+        credential.encryptedSharedCredentialEncryptionKey = serialized.encryptedSharedCredentialEncryptionKey;
+        if (serialized.acl) {
+            credential.acl = {
+                permissions: new SharingACL_1.SharingACL(serialized.acl.permission),
+                ...serialized.acl
+            };
+        }
+        return credential;
+    }
     async getRevisions() {
         return await this.server.getJson('/credentials/' + this.guid + '/revision', (response) => {
             this.server.logger.onError(response.message);
@@ -208,11 +291,11 @@ class Credential {
         };
     }
     /**
-     * Creates a local 100% clone of the current credential.
+     * Creates a local 100% clone of the current credential. The clone contains only encrypted data.
      */
     clone() {
         const newCredential = new Credential(this.vault, this.server, this.encryptedData);
-        newCredential.sharedCredentialEncryptionKey = this.sharedCredentialEncryptionKey;
+        newCredential.encryptedSharedCredentialEncryptionKey = this.encryptedSharedCredentialEncryptionKey;
         return newCredential;
     }
     /**
@@ -262,7 +345,10 @@ class Credential {
                 return this.decryptedDataCache.shared_key;
             }
         }
-        if (this.sharedCredentialEncryptionKey !== undefined) {
+        if (this.encryptedSharedCredentialEncryptionKey !== undefined) {
+            if (!this.sharedCredentialEncryptionKey) {
+                this.sharedCredentialEncryptionKey = PassmanCrypto_1.PassmanCrypto.decryptString(this.encryptedSharedCredentialEncryptionKey, this.vault.vaultKey);
+            }
             return this.sharedCredentialEncryptionKey;
         }
         return this.overwriteVaultKey ?? this.vault.vaultKey;
@@ -275,11 +361,17 @@ class Credential {
      */
     getCacheDecryptFieldData(property) {
         if (this.ENCRYPTED_FIELDS.indexOf(property) > -1) {
-            if (this.decryptedDataCache[property] === undefined) {
+            if (!Object.hasOwn(this.decryptedDataCache, property) || this.decryptedDataCache[property] === undefined) {
                 if (this.encryptedData[property] === null) {
                     this.decryptedDataCache[property] = null;
                 }
                 else {
+                    // should never happen, but who knows xD
+                    if (this.encryptedData[property] === undefined) {
+                        this.server.logger.anyError('Corrupt credential data detected. Undefined value for encryptedData.' + property + ' not allowed! encryptedData: ');
+                        this.server.logger.anyError(this.encryptedData);
+                        throw new Error('Corrupt credential data detected. Undefined value for encryptedData.' + property + ' not allowed!');
+                    }
                     let decryptedData;
                     try {
                         decryptedData = PassmanCrypto_1.PassmanCrypto.decryptString(this.encryptedData[property], this.getFieldEncryptionKey(property));
@@ -290,11 +382,13 @@ class Credential {
                         else {
                             this.decryptedDataCache[property] = JSON.parse(decryptedData);
                         }
+                        // should work, even if we do not wait for the returned Promise
+                        this.updateSerializedDecryptedDataCacheEntry(property);
                     }
                     catch (e) {
                         this.foundUnspecifiedEncryptionError = true;
                         this.server.logger.anyError(e);
-                        this.server.logger.anyError(decryptedData);
+                        this.server.logger.anyError(decryptedData ?? 'no decrypted data: (undefined)');
                         this.server.logger.onError('Failed to decrypt field: ' + property + ' of credential: ' + this.label);
                     }
                 }
@@ -319,7 +413,8 @@ class Credential {
                     this.encryptedData[property] = PassmanCrypto_1.PassmanCrypto.encryptString(data, this.getFieldEncryptionKey(property));
                 }
                 else {
-                    this.encryptedData[property] = PassmanCrypto_1.PassmanCrypto.encryptString(JSON.stringify(data), this.getFieldEncryptionKey(property));
+                    // use data ?? null to prevent undefined value (which could lead to an error in decryption)
+                    this.encryptedData[property] = PassmanCrypto_1.PassmanCrypto.encryptString(JSON.stringify(data ?? null), this.getFieldEncryptionKey(property));
                 }
             }
             catch (e) {
@@ -329,6 +424,7 @@ class Credential {
                 return;
             }
             this.decryptedDataCache[property] = data;
+            this.updateSerializedDecryptedDataCacheEntry(property);
         }
         else {
             this.encryptedData[property] = data;
@@ -359,7 +455,7 @@ class Credential {
                 logger.onError('Failed to decrypt file: ' + file.filename);
             }
         };
-        if (!this.encryptedData.acl) {
+        if (!this.acl) {
             return File_1.File.downloadFile(file, this.server).then(callback);
         }
         else {
@@ -383,7 +479,7 @@ class Credential {
             const callback = function (uploadFileResponse) {
                 return uploadFileResponse;
             };
-            if (!this.encryptedData.acl) {
+            if (!this.acl) {
                 return File_1.File.uploadFile(encryptedFile, this.server).then(callback);
             }
             else {
@@ -396,6 +492,24 @@ class Credential {
             this.server.logger.onError('Failed to encrypt new file (' + plainFile.filename + ') of credential: ' + this.label);
         }
     }
+    /**
+     * Serialized, encrypted credential data from non-object (string only) transfer methods (like WebExtension messaging api).
+     */
+    getAsSerializable() {
+        let acl = undefined;
+        if (this.acl) {
+            let { permissions, ...newAcl } = {
+                permission: this.acl.permissions.permission,
+                ...this.acl
+            };
+            acl = newAcl;
+        }
+        return {
+            encryptedData: this.getEncrypted(),
+            encryptedSharedCredentialEncryptionKey: this.encryptedSharedCredentialEncryptionKey,
+            acl
+        };
+    }
     /**
      * Deletes the given file from the server.
      * This method does *not* delete the file from the local credential files list!
@@ -573,22 +687,29 @@ class Credential {
         this.encryptedData.changed = value;
     }
     get set_share_key() {
-        return this.encryptedData.set_share_key;
+        return this._spacialServerUpdateFields.set_share_key;
     }
     set set_share_key(value) {
-        this.encryptedData.set_share_key = value;
+        this._spacialServerUpdateFields.set_share_key = value;
     }
     get skip_revision() {
-        return this.encryptedData.skip_revision;
+        return this._spacialServerUpdateFields.skip_revision;
     }
     set skip_revision(value) {
-        this.encryptedData.skip_revision = value;
+        this._spacialServerUpdateFields.skip_revision = value;
     }
     get acl() {
-        return this.encryptedData.acl;
+        return this._spacialServerUpdateFields.acl;
     }
+    /**
+     * Will be called short after credential instantiation by the ShareService.
+     * @param value
+     */
     set acl(value) {
-        this.encryptedData.acl = value;
+        this._spacialServerUpdateFields.acl = value;
+    }
+    get spacialServerUpdateFields() {
+        return this._spacialServerUpdateFields;
     }
 }
 exports.default = Credential;

package/lib/Model/File.d.ts

@@ -6,11 +6,11 @@ import { DeleteFilesRequestBodyInterface } from "../Interfaces/File/DeleteFilesR
 import { DeleteFilesResponseInterface } from "../Interfaces/File/DeleteFilesResponseInterface";
 import { FileDownloadResponseInterface } from "../Interfaces/File/FileDownloadResponseInterface";
 export declare class File {
-    static downloadFile: (file: FileInterface, server: NextcloudServerInterface) => Promise<void | FileDownloadResponseInterface>;
-    static downloadSharedFile: (credential: Credential, file: FileInterface, server: NextcloudServerInterface) => Promise<void | FileDownloadResponseInterface>;
-    static uploadFile: (fileWithEncryptedFields: FileInterface, server: NextcloudServerInterface) => Promise<void | FileUploadResponseInterface>;
-    static uploadSharedFile: (credential: Credential, fileWithEncryptedFields: FileInterface, server: NextcloudServerInterface) => Promise<void | FileUploadResponseInterface>;
-    static updateFile: (fileWithEncryptedFields: FileInterface, server: NextcloudServerInterface) => Promise<void | FileUploadResponseInterface>;
-    static deleteFile: (file: FileInterface, server: NextcloudServerInterface) => Promise<void | FileUploadResponseInterface>;
-    static deleteFiles: (deleteFilesRequestBody: DeleteFilesRequestBodyInterface, server: NextcloudServerInterface) => Promise<void | DeleteFilesResponseInterface>;
+    static readonly downloadFile: (file: FileInterface, server: NextcloudServerInterface) => Promise<void | FileDownloadResponseInterface>;
+    static readonly downloadSharedFile: (credential: Credential, file: FileInterface, server: NextcloudServerInterface) => Promise<void | FileDownloadResponseInterface>;
+    static readonly uploadFile: (fileWithEncryptedFields: FileInterface, server: NextcloudServerInterface) => Promise<void | FileUploadResponseInterface>;
+    static readonly uploadSharedFile: (credential: Credential, fileWithEncryptedFields: FileInterface, server: NextcloudServerInterface) => Promise<void | FileUploadResponseInterface>;
+    static readonly updateFile: (fileWithEncryptedFields: FileInterface, server: NextcloudServerInterface) => Promise<void | FileUploadResponseInterface>;
+    static readonly deleteFile: (file: FileInterface, server: NextcloudServerInterface) => Promise<void | FileUploadResponseInterface>;
+    static readonly deleteFiles: (deleteFilesRequestBody: DeleteFilesRequestBodyInterface, server: NextcloudServerInterface) => Promise<void | DeleteFilesResponseInterface>;
 }

package/lib/Model/NextcloudServer.d.ts

@@ -1,25 +1,26 @@
 import type { LoggingHandlerInterface } from "../Interfaces/LoggingHandlerInterface";
 import type { NextcloudServerInfoInterface } from "../Interfaces/NextcloudServer/NextcloudServerInfoInterface";
 import type { NextcloudServerInterface } from "../Interfaces/NextcloudServer/NextcloudServerInterface";
-import { RequestCachingHandlerInterface } from "../Interfaces/RequestCachingHandlerInterface";
+import { PersistenceInterface } from "../Interfaces/PersistenceInterface";
 export declare class NextcloudServer implements NextcloudServerInterface {
-    private serverData;
+    private readonly serverData;
     logger: LoggingHandlerInterface;
-    cache?: RequestCachingHandlerInterface;
+    persistence: PersistenceInterface;
+    static readonly getRequestCachePrefix = "cache-getJson-";
     /**
      * Create NextcloudServer instance.
      * @param serverData
      * @param logger
-     * @param cache
+     * @param persistence
      * @throws ConfigurationError
      */
-    constructor(serverData: NextcloudServerInfoInterface, logger: LoggingHandlerInterface, cache?: RequestCachingHandlerInterface);
+    constructor(serverData: NextcloudServerInfoInterface, logger: LoggingHandlerInterface, persistence: PersistenceInterface);
     getBaseUrl(): string;
-    setBaseUrl(value: string): string;
+    setBaseUrl(value: string): void;
     getUser(): string;
-    setUser(value: string): string;
+    setUser(value: string): void;
     getToken(): string;
-    setToken(value: string): string;
+    setToken(value: string): void;
     getApiUrl(): string;
     protected getEncodedLogin(): string;
     getJson: <T>(endpoint: string, errorCallback: (response: Error) => void, getCachedIfPossible?: boolean) => Promise<T | void>;

package/lib/Model/NextcloudServer.js

@@ -8,18 +8,19 @@ const ConfigurationError_1 = __importDefault(require("../Exception/Configuration
 class NextcloudServer {
     serverData;
     logger;
-    cache;
+    persistence;
+    static getRequestCachePrefix = 'cache-getJson-';
     /**
      * Create NextcloudServer instance.
      * @param serverData
      * @param logger
-     * @param cache
+     * @param persistence
      * @throws ConfigurationError
      */
-    constructor(serverData, logger, cache) {
+    constructor(serverData, logger, persistence) {
         this.serverData = serverData;
         this.logger = logger;
-        this.cache = cache;
+        this.persistence = persistence;
         if (!serverData.baseUrl.startsWith('https://') && !serverData.baseUrl.startsWith('http://')) {
             this.logger.onThrow(new ConfigurationError_1.default('Base URL (or protocol) is invalid'));
         }
@@ -31,22 +32,22 @@ class NextcloudServer {
         return this.serverData.baseUrl;
     }
     setBaseUrl(value) {
-        if (!value.startsWith('https://')) {
-            this.logger.onThrow(new ConfigurationError_1.default('Base URL is invalid'));
+        if (!value.startsWith('https://') && !value.startsWith('http://')) {
+            this.logger.onThrow(new ConfigurationError_1.default('Base URL (or protocol) is invalid'));
         }
-        return this.serverData.baseUrl = value;
+        this.serverData.baseUrl = value;
     }
     getUser() {
         return this.serverData.user;
     }
     setUser(value) {
-        return this.serverData.user = value;
+        this.serverData.user = value;
     }
     getToken() {
         return this.serverData.token;
     }
     setToken(value) {
-        return this.serverData.token = value;
+        this.serverData.token = value;
     }
     getApiUrl() {
         return `${this.getBaseUrl()}/index.php/apps/passman/api/v2/`;
@@ -55,9 +56,8 @@ class NextcloudServer {
         return btoa(this.getUser() + ":" + this.getToken());
     }
     getJson = async (endpoint, errorCallback, getCachedIfPossible = false) => {
-        const cachePrefix = 'cache-getJson-';
-        if (getCachedIfPossible && this.cache) {
-            const cachedValue = await this.cache.get(cachePrefix + endpoint);
+        if (getCachedIfPossible && this.persistence.getRequestCacheHandler()) {
+            const cachedValue = await this.persistence.getRequestCacheHandler().get(NextcloudServer.getRequestCachePrefix + endpoint);
             if (cachedValue && cachedValue !== '') {
                 try {
                     return JSON.parse(cachedValue);
@@ -83,8 +83,8 @@ class NextcloudServer {
             return;
         }
         const jsonResponse = await res.json();
-        if (this.cache) {
-            await this.cache.set(cachePrefix + endpoint, JSON.stringify(jsonResponse));
+        if (this.persistence.getRequestCacheHandler()) {
+            await this.persistence.getRequestCacheHandler().set(NextcloudServer.getRequestCachePrefix + endpoint, JSON.stringify(jsonResponse));
         }
         return (jsonResponse);
     };

package/lib/Model/PreloadedVault.d.ts

@@ -0,0 +1,20 @@
+import { GenericVaultInformationFromServerInterface, VaultsGetResponseFromServer } from "../Interfaces/Vault/GenericVaultInformationFromServerInterface";
+import { NextcloudServerInterface } from "../Interfaces/NextcloudServer/NextcloudServerInterface";
+/**
+ * The PreloadedVault contains only generic vault information, got from the /api/v1/vaults GET request.
+ * It can be used as fast and small data structure during vault authentication, before any modification or credential is needed.
+ */
+export default class PreloadedVault {
+    protected genericVaultInformation: GenericVaultInformationFromServerInterface;
+    protected server: NextcloudServerInterface;
+    constructor(genericVaultInformation: GenericVaultInformationFromServerInterface, server: NextcloudServerInterface);
+    /**
+     * Tests the vault key on the challenge_password
+     * @param vaultKey
+     */
+    testVaultKey(vaultKey: string): boolean;
+    static parseResponse(vaultsResponse: void | VaultsGetResponseFromServer, server: NextcloudServerInterface): void | PreloadedVault[];
+    get id(): number;
+    get guid(): string;
+    get name(): string;
+}

package/lib/Model/PreloadedVault.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PassmanCrypto_1 = require("../Service/PassmanCrypto");
+/**
+ * The PreloadedVault contains only generic vault information, got from the /api/v1/vaults GET request.
+ * It can be used as fast and small data structure during vault authentication, before any modification or credential is needed.
+ */
+class PreloadedVault {
+    genericVaultInformation;
+    server;
+    constructor(genericVaultInformation, server) {
+        this.genericVaultInformation = genericVaultInformation;
+        this.server = server;
+    }
+    /**
+     * Tests the vault key on the challenge_password
+     * @param vaultKey
+     */
+    testVaultKey(vaultKey) {
+        try {
+            if (this.genericVaultInformation.challenge_password) {
+                PassmanCrypto_1.PassmanCrypto.decryptString(this.genericVaultInformation.challenge_password, vaultKey);
+                return true;
+            }
+            else {
+                console.error('May we need credentials to test the vault key!');
+                // would require fetching the full vault, instead of using this PreloadedVault
+                return false;
+            }
+        }
+        catch (e) {
+        }
+        return false;
+    }
+    static parseResponse(vaultsResponse, server) {
+        if (vaultsResponse) {
+            let newPreloadedVaults = [];
+            vaultsResponse.forEach((vaultInformationFromServer) => {
+                newPreloadedVaults.push(new PreloadedVault(vaultInformationFromServer, server));
+            });
+            return newPreloadedVaults;
+        }
+    }
+    get id() {
+        return this.genericVaultInformation.vault_id;
+    }
+    get guid() {
+        return this.genericVaultInformation.guid;
+    }
+    get name() {
+        return this.genericVaultInformation.name;
+    }
+}
+exports.default = PreloadedVault;

package/lib/Model/Revision.d.ts

@@ -1,9 +1,9 @@
 import Credential from "./Credential";
 import { NextcloudServerInterface } from "../Interfaces/NextcloudServer/NextcloudServerInterface";
 import type Vault from "./Vault";
-import { EncryptedCredentialInterface } from "../Interfaces/Credential/EncryptedCredentialInterface";
 import { FileUploadResponseInterface } from "../Interfaces/File/FileUploadResponseInterface";
 import { RevisionInterface } from "../Interfaces/Revision/RevisionInterface";
+import { EncryptedOwnedCredentialFromServerInterface } from "../Interfaces/Credential/EncryptedOwnedCredentialFromServerInterface";
 export default class Revision extends Credential {
     ENCRYPTED_FIELDS: string[];
     static updateRevision(revision: RevisionInterface, server: NextcloudServerInterface): Promise<void | FileUploadResponseInterface>;
@@ -13,9 +13,9 @@ export default class Revision extends Credential {
      * @param vault
      * @param server
      */
-    static fromData(data: EncryptedCredentialInterface, vault: Vault, server: NextcloudServerInterface): Promise<Revision>;
+    static fromData(data: EncryptedOwnedCredentialFromServerInterface, vault: Vault, server: NextcloudServerInterface): Revision;
     /**
-     * Creates a local 100% clone of the current credential.
+     * Creates a local 100% clone of the current credential. The clone contains only encrypted data.
      */
     clone(): Revision;
 }

package/lib/Model/Revision.js

@@ -19,15 +19,15 @@ class Revision extends Credential_1.default {
      * @param vault
      * @param server
      */
-    static async fromData(data, vault, server) {
+    static fromData(data, vault, server) {
         return new Revision(vault, server, data);
     }
     /**
-     * Creates a local 100% clone of the current credential.
+     * Creates a local 100% clone of the current credential. The clone contains only encrypted data.
      */
     clone() {
         const newCredential = new Revision(this.vault, this.server, this.encryptedData);
-        newCredential.sharedCredentialEncryptionKey = this.sharedCredentialEncryptionKey;
+        newCredential.encryptedSharedCredentialEncryptionKey = this.encryptedSharedCredentialEncryptionKey;
         return newCredential;
     }
 }

package/lib/Model/SharingACL.d.ts

@@ -1,6 +1,6 @@
 export declare class SharingACL {
-    private permission;
-    constructor(permission: number);
+    private _permission;
+    constructor(_permission: number);
     static readonly permissions: {
         READ: number;
         WRITE: number;
@@ -25,4 +25,5 @@ export declare class SharingACL {
     removePermission(permission: any): void;
     togglePermission(permission: any): void;
     getAccessLevel(): number;
+    get permission(): number;
 }

package/lib/Model/SharingACL.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SharingACL = void 0;
 class SharingACL {
-    permission;
-    constructor(permission) {
-        this.permission = permission;
+    _permission;
+    constructor(_permission) {
+        this._permission = _permission;
     }
     static permissions = {
         READ: 0x01,
@@ -26,7 +26,7 @@ class SharingACL {
      * @param permission
      */
     addPermission(permission) {
-        this.permission = this.permission | permission;
+        this._permission = this.permission | permission;
     }
     ;
     /**
@@ -34,15 +34,18 @@ class SharingACL {
      * @param permission
      */
     removePermission(permission) {
-        this.permission = this.permission & ~permission;
+        this._permission = this.permission & ~permission;
     }
     ;
     togglePermission(permission) {
-        this.permission ^= permission;
+        this._permission ^= permission;
     }
     ;
     getAccessLevel() {
         return this.permission;
     }
+    get permission() {
+        return this._permission;
+    }
 }
 exports.SharingACL = SharingACL;