favalib 0.0.1

package/build/interfaces/Vault.d.mts

@@ -0,0 +1,30 @@
+import type { Tagged } from 'type-fest';
+import type { Encrypted, EncryptedPrivateKey, EncryptedSymmetricKey, Salt } from './CryptoLib.mjs';
+import type Entry from './Entry.mjs';
+import { DeviceId, SyncDevice } from './SyncTypes.mjs';
+import { SyncCommandFromClient } from 'favaserver/ClientMessage';
+export type Vault = Entry[];
+export type EncryptedVaultStateString = Encrypted<VaultStateString>;
+export interface LockedRepresentation {
+    encryptedPrivateKey: EncryptedPrivateKey;
+    encryptedSymmetricKey: EncryptedSymmetricKey;
+    salt: Salt;
+    encryptedVaultState: EncryptedVaultStateString;
+    libVersion: string;
+    storageVersion: number;
+}
+export type LockedRepresentationString = Tagged<string, 'LockedRepresentationString'>;
+export interface VaultSyncState {
+    devices: SyncDevice[];
+    serverUrl: string | undefined;
+    commandSendQueue: SyncCommandFromClient[];
+}
+export type VaultSyncStateWithServerUrl = Omit<VaultSyncState, 'serverUrl'> & {
+    serverUrl: NonNullable<VaultSyncState['serverUrl']>;
+};
+export interface VaultState {
+    deviceId: DeviceId;
+    vault: Vault;
+    sync: VaultSyncState;
+}
+export type VaultStateString = Tagged<string, 'VaultState'>;

package/build/interfaces/Vault.mjs

@@ -0,0 +1 @@
+export {};

package/build/main.d.mts

@@ -0,0 +1,12 @@
+import TwoFaLib from './TwoFaLib.mjs';
+import type Entry from './interfaces/Entry.mjs';
+import type { EntryId, NewEntry, EntryMeta, EntryType, TotpPayload, Token, EntryMetaWithToken } from './interfaces/Entry.mjs';
+import type CryptoLib from './interfaces/CryptoLib.mjs';
+import type { Encrypted, EncryptedPrivateKey, EncryptedSymmetricKey, EncryptedPublicKey, PrivateKey, SymmetricKey, PublicKey, Passphrase, Salt } from './interfaces/CryptoLib.mjs';
+import type { SyncDevice, DeviceId, DeviceType } from './interfaces/SyncTypes.mjs';
+import type { EncryptedVaultStateString, LockedRepresentationString } from './interfaces/Vault.mjs';
+import { TwoFALibError, InitializationError, AuthenticationError, EntryNotFoundError, TokenGenerationError } from './TwoFALibError.mjs';
+import { TwoFaLibEvent } from './TwoFaLibEvent.mjs';
+import { getTwoFaLibVaultCreationUtils } from './utils/creationUtils.mjs';
+export { TwoFaLib, TwoFALibError, getTwoFaLibVaultCreationUtils, InitializationError, AuthenticationError, EntryNotFoundError, TokenGenerationError, TwoFaLibEvent, };
+export type { Entry, EntryId, NewEntry, EntryMeta, EntryMetaWithToken, EntryType, TotpPayload, Token, EncryptedVaultStateString, LockedRepresentationString, CryptoLib, Encrypted, EncryptedPrivateKey, EncryptedPublicKey, EncryptedSymmetricKey, PrivateKey, SymmetricKey, PublicKey, Passphrase, Salt, DeviceId, DeviceType, SyncDevice, };

package/build/main.mjs

@@ -0,0 +1,5 @@
+import TwoFaLib from './TwoFaLib.mjs';
+import { TwoFALibError, InitializationError, AuthenticationError, EntryNotFoundError, TokenGenerationError, } from './TwoFALibError.mjs';
+import { TwoFaLibEvent } from './TwoFaLibEvent.mjs';
+import { getTwoFaLibVaultCreationUtils } from './utils/creationUtils.mjs';
+export { TwoFaLib, TwoFALibError, getTwoFaLibVaultCreationUtils, InitializationError, AuthenticationError, EntryNotFoundError, TokenGenerationError, TwoFaLibEvent, };

package/build/subclasses/CommandManager.d.mts

@@ -0,0 +1,46 @@
+import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
+import type Command from '../Command/BaseCommand.mjs';
+import { type SyncCommand } from '../interfaces/CommandTypes.mjs';
+/**
+ * Manages the execution, undo, and redo of commands.
+ */
+declare class CommandManager {
+    private readonly mediator;
+    private executedCommands;
+    private undoneCommands;
+    private remoteCommandQueue;
+    private processedCommandIds;
+    /**
+     * Constructs a new CommandManager instance.
+     * @param mediator - The mediator for accessing other components.
+     */
+    constructor(mediator: TwoFaLibMediator);
+    private get syncManager();
+    private get log();
+    /**
+     * Executes a command and manages its state.
+     * @param command - The command to execute.
+     */
+    execute(command: Command): Promise<void>;
+    /**
+     * Undoes the last executed command.
+     */
+    undo(): Promise<void>;
+    /**
+     * Redoes the last undone command.
+     */
+    redo(): Promise<void>;
+    /**
+     * Processes all commands in the remote command queue.
+     * @returns An array of the IDs of the succesfully executed commands.
+     */
+    processRemoteCommands(): Promise<string[]>;
+    /**
+     * Receives a remote command and enqueues it for processing.
+     * @param remoteCommand - The remote command to process.
+     * @throws {InvalidCommandError} If the command type is unknown or data is invalid.
+     */
+    receiveRemoteCommand(remoteCommand: SyncCommand): void;
+    private sendCommandToOtherInstances;
+}
+export default CommandManager;

package/build/subclasses/CommandManager.mjs

@@ -0,0 +1,117 @@
+import { InvalidCommandError } from '../TwoFALibError.mjs';
+import commandConstructors from '../Command/commandConstructors.mjs';
+import CommandQueue from '../Command/CommandQueue.mjs';
+/**
+ * Manages the execution, undo, and redo of commands.
+ */
+class CommandManager {
+    /**
+     * Constructs a new CommandManager instance.
+     * @param mediator - The mediator for accessing other components.
+     */
+    constructor(mediator) {
+        this.mediator = mediator;
+        this.executedCommands = [];
+        this.undoneCommands = [];
+        this.remoteCommandQueue = new CommandQueue();
+        this.processedCommandIds = new Set();
+    }
+    get syncManager() {
+        if (!this.mediator.componentIsInitialised('syncManager')) {
+            return null;
+        }
+        return this.mediator.getComponent('syncManager');
+    }
+    get log() {
+        return this.mediator.getComponent('log');
+    }
+    /**
+     * Executes a command and manages its state.
+     * @param command - The command to execute.
+     */
+    async execute(command) {
+        if (this.processedCommandIds.has(command.id)) {
+            this.log('warning', `Command ${command.id} has already been processed`);
+            return;
+        }
+        await command.execute(this.mediator);
+        this.processedCommandIds.add(command.id);
+        if (!command.fromRemote) {
+            this.executedCommands.push(command);
+            await this.sendCommandToOtherInstances(command);
+        }
+        this.undoneCommands = [];
+    }
+    /**
+     * Undoes the last executed command.
+     */
+    async undo() {
+        const command = this.executedCommands.pop();
+        if (command) {
+            const undoCommand = command.createUndoCommand(this.mediator);
+            await undoCommand.execute(this.mediator);
+            this.undoneCommands.push(command);
+        }
+    }
+    /**
+     * Redoes the last undone command.
+     */
+    async redo() {
+        const command = this.undoneCommands.pop();
+        if (command) {
+            await command.execute(this.mediator);
+            this.executedCommands.push(command);
+        }
+    }
+    /**
+     * Processes all commands in the remote command queue.
+     * @returns An array of the IDs of the succesfully executed commands.
+     */
+    async processRemoteCommands() {
+        const executedIds = [];
+        while (!this.remoteCommandQueue.isEmpty()) {
+            const command = this.remoteCommandQueue.dequeue();
+            if (command) {
+                try {
+                    await this.execute(command);
+                    executedIds.push(command.id);
+                }
+                catch (err) {
+                    // eslint-disable-next-line no-restricted-globals
+                    if (err instanceof Error) {
+                        this.log('warning', 'Error while processing remote commands: ' + err.message);
+                    }
+                    this.log('warning', 'Unknown error while processing remote commands');
+                }
+            }
+        }
+        return executedIds;
+    }
+    /**
+     * Receives a remote command and enqueues it for processing.
+     * @param remoteCommand - The remote command to process.
+     * @throws {InvalidCommandError} If the command type is unknown or data is invalid.
+     */
+    receiveRemoteCommand(remoteCommand) {
+        if (remoteCommand && typeof remoteCommand.type === 'string') {
+            const CommandClass = commandConstructors[remoteCommand.type];
+            if (CommandClass) {
+                const command = CommandClass.fromJSON(remoteCommand);
+                this.remoteCommandQueue.enqueue(command);
+            }
+            else {
+                throw new InvalidCommandError(`Unknown command type: ${remoteCommand.type}`);
+            }
+        }
+        else {
+            throw new InvalidCommandError('Invalid command data received');
+        }
+    }
+    async sendCommandToOtherInstances(command) {
+        if (!this.syncManager) {
+            return Promise.resolve();
+        }
+        await this.syncManager.sendCommand(command);
+    }
+}
+export default CommandManager;

package/build/subclasses/ExportImportManager.d.mts

@@ -0,0 +1,58 @@
+import { EntryId } from '../interfaces/Entry.mjs';
+import type { PassphraseExtraDict } from '../interfaces/PassphraseExtraDict.js';
+import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
+/**
+ * Manages the export and import of entries in various formats.
+ */
+declare class ExportImportManager {
+    private readonly mediator;
+    private readonly passphraseExtraDict;
+    /**
+     * Constructs a new instance of ExportImportManager.
+     * @param mediator - The mediator for accessing other components.
+     * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+     */
+    constructor(mediator: TwoFaLibMediator, passphraseExtraDict: PassphraseExtraDict);
+    private get libraryLoader();
+    private get vaultDataManager();
+    private get vaultOperationsManager();
+    private get persistentStorageManager();
+    /**
+     * Export entries in the specified format, optionally (when a password is provided) encrypted.
+     * If the password is not provided, the user be warned about the dangers of exporting clear text.
+     * @param format - The export format ('text' or 'html').
+     * @param passphrase - Optional password for encryption.
+     * @param userWasWarnedAboutExportingClearText - Whether the user was warned about exporting clear text.
+     * @returns A promise that resolves to the exported data as a string.
+     */
+    exportEntries(format: 'text' | 'html', passphrase?: string, userWasWarnedAboutExportingClearText?: boolean): Promise<string>;
+    private generateTextExport;
+    private generateHtmlExport;
+    /**
+     * Import entries from a text file, optionally (when a password is provided) decrypt first
+     * @param fileContents - The contents of the text file.
+     * @param passphrase - Optional password for decryption.
+     * @returns A promise that resolves to an array of objects, each containing the line number,
+     *          the EntryId or null if it was not a valid entry and the error if there was one.
+     */
+    importFromTextFile(fileContents: string, passphrase?: string): Promise<{
+        lineNr: number;
+        entryId: EntryId | null;
+        error: unknown;
+    }[]>;
+    /**
+     * Import an entry from an OTP URI.
+     * @param otpUri - The OTP URI to import
+     * @returns A promise that resolves to the newly added EntryId.
+     * @throws {ExportImportError} If the URI is invalid or contains unsupported OTP type.
+     */
+    importFromUri(otpUri: string): Promise<EntryId>;
+    /**
+     * Import an entry from a QR code image.
+     * @param imageInput - The image containing the QR code
+     * @returns A promise that resolves to the newly added EntryId.
+     * @throws {InvalidInputExportImportError} If the QR code is invalid or doesn't contain a valid OTP URI.
+     */
+    importFromQRCode(imageInput: string | File | Uint8Array): Promise<EntryId>;
+}
+export default ExportImportManager;

package/build/subclasses/ExportImportManager.mjs

@@ -0,0 +1,105 @@
+import { parseOtpUri, generateHtmlExport, generateTextExport, processImportLines, encryptExport, decryptExport, } from '../utils/exportImportUtils.mjs';
+import { getDataFromQRImage } from '../utils/qrUtils.mjs';
+import { ExportImportError } from '../TwoFALibError.mjs';
+import { validatePassphraseStrength } from '../utils/creationUtils.mjs';
+/**
+ * Manages the export and import of entries in various formats.
+ */
+class ExportImportManager {
+    /**
+     * Constructs a new instance of ExportImportManager.
+     * @param mediator - The mediator for accessing other components.
+     * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+     */
+    constructor(mediator, passphraseExtraDict) {
+        this.mediator = mediator;
+        this.passphraseExtraDict = passphraseExtraDict;
+    }
+    get libraryLoader() {
+        return this.mediator.getComponent('libraryLoader');
+    }
+    get vaultDataManager() {
+        return this.mediator.getComponent('vaultDataManager');
+    }
+    get vaultOperationsManager() {
+        return this.mediator.getComponent('vaultOperationsManager');
+    }
+    get persistentStorageManager() {
+        return this.mediator.getComponent('persistentStorageManager');
+    }
+    /**
+     * Export entries in the specified format, optionally (when a password is provided) encrypted.
+     * If the password is not provided, the user be warned about the dangers of exporting clear text.
+     * @param format - The export format ('text' or 'html').
+     * @param passphrase - Optional password for encryption.
+     * @param userWasWarnedAboutExportingClearText - Whether the user was warned about exporting clear text.
+     * @returns A promise that resolves to the exported data as a string.
+     */
+    async exportEntries(format, passphrase, userWasWarnedAboutExportingClearText) {
+        let exportData;
+        if (!passphrase && !userWasWarnedAboutExportingClearText) {
+            throw new ExportImportError('User was not warned about the dangers of unencrypted exporting');
+        }
+        if (format === 'text') {
+            exportData = this.generateTextExport();
+        }
+        else if (format === 'html') {
+            exportData = await this.generateHtmlExport();
+        }
+        else {
+            throw new ExportImportError('Invalid export format');
+        }
+        if (passphrase) {
+            await validatePassphraseStrength(this.libraryLoader, passphrase, this.passphraseExtraDict);
+            return encryptExport(await this.libraryLoader.getOpenPGPLib(), exportData, passphrase);
+        }
+        return exportData;
+    }
+    generateTextExport() {
+        return generateTextExport(this.vaultDataManager.getAllEntries());
+    }
+    async generateHtmlExport() {
+        const qrGeneratorLib = await this.libraryLoader.getQrGeneratorLib();
+        return generateHtmlExport(qrGeneratorLib, this.vaultDataManager.getAllEntries());
+    }
+    /**
+     * Import entries from a text file, optionally (when a password is provided) decrypt first
+     * @param fileContents - The contents of the text file.
+     * @param passphrase - Optional password for decryption.
+     * @returns A promise that resolves to an array of objects, each containing the line number,
+     *          the EntryId or null if it was not a valid entry and the error if there was one.
+     */
+    async importFromTextFile(fileContents, passphrase) {
+        if (passphrase) {
+            const decrypted = await decryptExport(await this.libraryLoader.getOpenPGPLib(), fileContents, passphrase);
+            return this.importFromTextFile(decrypted);
+        }
+        const lines = fileContents.trim().split('\n');
+        const result = await processImportLines(lines, (uri) => this.importFromUri(uri));
+        // force save to make sure we're not caught in a race condition
+        await this.persistentStorageManager.save();
+        return result;
+    }
+    /**
+     * Import an entry from an OTP URI.
+     * @param otpUri - The OTP URI to import
+     * @returns A promise that resolves to the newly added EntryId.
+     * @throws {ExportImportError} If the URI is invalid or contains unsupported OTP type.
+     */
+    async importFromUri(otpUri) {
+        const UrlParser = await this.libraryLoader.getUrlParserLib();
+        const newEntry = parseOtpUri(UrlParser, otpUri.trim());
+        return this.vaultOperationsManager.addEntry(newEntry);
+    }
+    /**
+     * Import an entry from a QR code image.
+     * @param imageInput - The image containing the QR code
+     * @returns A promise that resolves to the newly added EntryId.
+     * @throws {InvalidInputExportImportError} If the QR code is invalid or doesn't contain a valid OTP URI.
+     */
+    async importFromQRCode(imageInput) {
+        const otpUri = await getDataFromQRImage(this.libraryLoader, imageInput);
+        return this.importFromUri(otpUri);
+    }
+}
+export default ExportImportManager;

package/build/subclasses/LibraryLoader.d.mts

@@ -0,0 +1,56 @@
+import type CryptoLib from '../interfaces/CryptoLib.mjs';
+/**
+ * Class responsible for loading various external (big) libraries required by the application.
+ * All libraries (except CryptoLib) are loaded on demand. This helps to reduce the initial bundle size.
+ */
+declare class LibraryLoader {
+    private cryptoLib;
+    private openPgpLib?;
+    private qrGeneratorLib?;
+    private jsQrLib?;
+    private canvasLib?;
+    private urlParserLib?;
+    private zxcvbn?;
+    /**
+     * Constructs a new instance of LibraryLoader.
+     * @param cryptoLib - An instance of CryptoLib that is required for library operations.
+     * @throws {InitializationError} If the provided CryptoLib instance is invalid.
+     */
+    constructor(cryptoLib: CryptoLib);
+    /**
+     * @returns The CryptoLib instance.
+     */
+    getCryptoLib(): CryptoLib;
+    /**
+     * Loads and returns the OpenPGP library on demand.
+     * @returns A promise that resolves to the OpenPGP library.
+     */
+    getOpenPGPLib(): Promise<typeof import("openpgp")>;
+    /**
+     * Loads and returns the QR Generator library on demand.
+     * @returns A promise that resolves to the QR Generator library.
+     */
+    getQrGeneratorLib(): Promise<typeof import("qrcode")>;
+    /**
+     * Loads and returns the JsQR library on demand.
+     * @returns A promise that resolves to the JsQR library.
+     */
+    getJsQrLib(): Promise<typeof import("jsqr").default>;
+    /**
+     * Loads and returns the Canvas library on demand.
+     * @returns A promise that resolves to the Canvas library.
+     * @throws {TwoFALibError} If the library cannot be loaded in a browser environment.
+     */
+    getCanvasLib(): Promise<typeof import("canvas")>;
+    /**
+     * Loads and returns the URL Parser library on demand.
+     * @returns A promise that resolves to the URL Parser library.
+     */
+    getUrlParserLib(): Promise<typeof import("whatwg-url")>;
+    /**
+     * Loads and returns the Zxcvbn library on demand.
+     * @returns A promise that resolves to the Zxcvbn library.
+     */
+    getZxcvbn(): Promise<(password: string, userInputs?: (string | number)[]) => import("@zxcvbn-ts/core").ZxcvbnResult>;
+}
+export default LibraryLoader;

package/build/subclasses/LibraryLoader.mjs

@@ -0,0 +1,108 @@
+import { InitializationError, TwoFALibError } from '../TwoFALibError.mjs';
+/**
+ * Class responsible for loading various external (big) libraries required by the application.
+ * All libraries (except CryptoLib) are loaded on demand. This helps to reduce the initial bundle size.
+ */
+class LibraryLoader {
+    /**
+     * Constructs a new instance of LibraryLoader.
+     * @param cryptoLib - An instance of CryptoLib that is required for library operations.
+     * @throws {InitializationError} If the provided CryptoLib instance is invalid.
+     */
+    constructor(cryptoLib) {
+        if (!cryptoLib) {
+            throw new InitializationError('CryptoLib is required');
+        }
+        this.cryptoLib = cryptoLib;
+    }
+    /**
+     * @returns The CryptoLib instance.
+     */
+    getCryptoLib() {
+        return this.cryptoLib;
+    }
+    /**
+     * Loads and returns the OpenPGP library on demand.
+     * @returns A promise that resolves to the OpenPGP library.
+     */
+    async getOpenPGPLib() {
+        if (!this.openPgpLib) {
+            const module = await import('openpgp');
+            // enable Authenticated Encryption with Associated Data
+            module.config.aeadProtect = true;
+            this.openPgpLib = module;
+        }
+        return this.openPgpLib;
+    }
+    /**
+     * Loads and returns the QR Generator library on demand.
+     * @returns A promise that resolves to the QR Generator library.
+     */
+    async getQrGeneratorLib() {
+        if (!this.qrGeneratorLib) {
+            const module = await import('qrcode');
+            this.qrGeneratorLib = module.default;
+        }
+        return this.qrGeneratorLib;
+    }
+    /**
+     * Loads and returns the JsQR library on demand.
+     * @returns A promise that resolves to the JsQR library.
+     */
+    async getJsQrLib() {
+        if (!this.jsQrLib) {
+            const module = await import('jsqr');
+            this.jsQrLib = module.default.default;
+        }
+        return this.jsQrLib;
+    }
+    /**
+     * Loads and returns the Canvas library on demand.
+     * @returns A promise that resolves to the Canvas library.
+     * @throws {TwoFALibError} If the library cannot be loaded in a browser environment.
+     */
+    async getCanvasLib() {
+        if (typeof window !== 'undefined') {
+            throw new TwoFALibError('Canvas lib can not be loaded in browser env');
+        }
+        if (!this.canvasLib) {
+            const module = await import('canvas');
+            this.canvasLib = module.default;
+        }
+        return this.canvasLib;
+    }
+    /**
+     * Loads and returns the URL Parser library on demand.
+     * @returns A promise that resolves to the URL Parser library.
+     */
+    async getUrlParserLib() {
+        if (!this.urlParserLib) {
+            const module = await import('whatwg-url');
+            this.urlParserLib = module.default;
+        }
+        return this.urlParserLib;
+    }
+    /**
+     * Loads and returns the Zxcvbn library on demand.
+     * @returns A promise that resolves to the Zxcvbn library.
+     */
+    async getZxcvbn() {
+        if (!this.zxcvbn) {
+            const { zxcvbn, zxcvbnOptions } = await import('@zxcvbn-ts/core');
+            const zxcvbnCommonPackage = await import('@zxcvbn-ts/language-common');
+            const zxcvbnEnPackage = await import('@zxcvbn-ts/language-en');
+            const options = {
+                translations: zxcvbnEnPackage.translations,
+                graphs: zxcvbnCommonPackage.adjacencyGraphs,
+                dictionary: {
+                    ...zxcvbnCommonPackage.dictionary,
+                    ...zxcvbnEnPackage.dictionary,
+                },
+            };
+            zxcvbnOptions.setOptions(options);
+            this.zxcvbn = zxcvbn;
+        }
+        return this.zxcvbn;
+    }
+}
+export default LibraryLoader;

package/build/subclasses/PersistentStorageManager.d.mts

@@ -0,0 +1,71 @@
+import type { EncryptedPrivateKey, EncryptedSymmetricKey, Passphrase, PrivateKey, Salt, SymmetricKey } from '../interfaces/CryptoLib.mjs';
+import { EncryptedVaultStateString, LockedRepresentationString } from '../interfaces/Vault.mjs';
+import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
+import type { DeviceId } from '../interfaces/SyncTypes.mjs';
+import type { PassphraseExtraDict } from '../interfaces/PassphraseExtraDict.js';
+/**
+ * Manages all storage of data that should be persistent.
+ */
+declare class PersistentStorageManager {
+    private mediator;
+    private readonly passphraseExtraDict;
+    private readonly deviceId;
+    private readonly privateKey;
+    private readonly symmetricKey;
+    private encryptedPrivateKey;
+    private encryptedSymmetricKey;
+    private salt;
+    static readonly storageVersion = 1;
+    /**
+     * Constructs a new instance of PersistentStorageManager.
+     * @param mediator - The mediator for accessing other components.
+     * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+     * @param deviceId - The unique identifier of the device.
+     * @param privateKey - The private key used for cryptographic operations.
+     * @param symmetricKey - The symmetric key used for cryptographic operations.
+     * @param encryptedPrivateKey - The encrypted private key
+     * @param encryptedSymmetricKey - The encrypted symmetric key
+     * @param salt - The salt used for key derivation.
+     */
+    constructor(mediator: TwoFaLibMediator, passphraseExtraDict: PassphraseExtraDict, deviceId: DeviceId, privateKey: PrivateKey, symmetricKey: SymmetricKey, encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt);
+    private get cryptoLib();
+    private get vaultDataManager();
+    private get syncManager();
+    private get dispatchLibEvent();
+    /**
+     * Retrieves an encrypted representation of the library's current state.
+     * This can be used for secure storage or transmission of the library's data.
+     * @param key - The key to decrypt the locked representation with. If not provided the library's current symmetric key will be used.
+     * @returns A promise that resolves with a string representation of the locked state.
+     */
+    getEncryptedVaultState(key?: SymmetricKey): Promise<EncryptedVaultStateString>;
+    /**
+     * Creates a partially encrypted representation of all data, except for
+     * the passphrase, that is needed to load the library. This can be used
+     * for secure storage of the library's data.
+     * @returns A promise that resolves with a json encoded string of
+     * the partially encrypted library's data.
+     */
+    getLockedRepresentation(): Promise<LockedRepresentationString>;
+    /**
+     * Saves the current state of the library.
+     * @returns A promise that resolves when the save operation is complete.
+     */
+    save(): Promise<void>;
+    /**
+     * Validates the provided passphrase against the current library passphrase.
+     * @param salt - The salt used for key derivation.
+     * @param passphrase - The passphrase to validate.
+     * @returns A promise that resolves with a boolean indicating whether the passphrase is valid.
+     */
+    validatePassphrase(salt: Salt, passphrase: Passphrase): Promise<boolean>;
+    /**
+     * Changes the library's passphrase.
+     * @param oldPassphrase - The current passphrase.
+     * @param newPassphrase - The new passphrase to set.
+     * @returns A promise that resolves when the passphrase change is complete.
+     * @throws {AuthenticationError} If the provided old passphrase is incorrect.
+     */
+    changePassphrase(oldPassphrase: Passphrase, newPassphrase: Passphrase): Promise<void>;
+}
+export default PersistentStorageManager;