favalib 0.0.1

package/build/subclasses/VaultDataManager.mjs

@@ -0,0 +1,114 @@
+import { TOTP } from 'totp-generator';
+import { EntryNotFoundError, TokenGenerationError } from '../TwoFALibError.mjs';
+import { SUPPORTED_ALGORITHMS, } from '../utils/constants.mjs';
+/**
+ * Manages the data within the vault. This class should only be used internally
+ * by the library, for public methods, see VaultOperationsManager.
+ */
+class VaultDataManager {
+    /**
+     * Constructs a new VaultDataManager instance.
+     * @param mediator - The mediator for accessing other components.
+     */
+    constructor(mediator) {
+        this.mediator = mediator;
+        this.vault = [];
+    }
+    get persistentStorageManager() {
+        return this.mediator.getComponent('persistentStorageManager');
+    }
+    /**
+     * @returns The number of entries in the vault.
+     */
+    get size() {
+        return this.vault.length;
+    }
+    /**
+     * Retrieve a specific entry.
+     * @param entryId - The unique identifier of the entry.
+     * @returns The entry.
+     * @throws {EntryNotFoundError} If no entry exists with the given ID.
+     */
+    getFullEntry(entryId) {
+        const entry = this.vault.find((e) => e.id === entryId);
+        if (!entry)
+            throw new EntryNotFoundError('Entry not found');
+        return entry;
+    }
+    /**
+     * Retrieve all entries in the vault.
+     * @returns An array of all entries.
+     */
+    getAllEntries() {
+        return this.vault;
+    }
+    /**
+     * Generate a time-based one-time password (TOTP) for a specific entry.
+     * @param id - The unique identifier of the entry.
+     * @param timestamp - Optional timestamp to use for token generation (default is current time).
+     * @returns An object containing the token and the validity period.
+     * @throws {EntryNotFoundError} If no entry exists with the given ID.
+     * @throws {TokenGenerationError} If token generation fails due to invalid entry data or technical issues.
+     */
+    generateTokenForEntry(id, timestamp) {
+        const entry = this.vault.find((e) => e.id === id);
+        if (!entry || entry.type !== 'TOTP') {
+            throw new EntryNotFoundError('TOTP entry not found');
+        }
+        const { secret, period, algorithm, digits } = entry.payload;
+        if (!SUPPORTED_ALGORITHMS.includes(algorithm)) {
+            throw new TokenGenerationError(`Algorithm ${algorithm} is not supported`);
+        }
+        const totpOptions = {
+            digits,
+            period,
+            algorithm: algorithm,
+            timestamp: timestamp ?? Date.now(),
+        };
+        const { otp, expires } = TOTP.generate(secret, totpOptions);
+        return { otp, validFrom: expires - period * 1000, validTill: expires };
+    }
+    /**
+     * Add a new entry to the vault.
+     * @param entry - The entry data to add (without an ID, as it will be generated).
+     * @returns A promise that resolves when the entry is added.
+     */
+    async addEntry(entry) {
+        this.vault.push(entry);
+        await this.persistentStorageManager.save();
+    }
+    /**
+     * Delete an entry from the vault.
+     * @param entryId - The identifier of the entry to delete.
+     * @throws {EntryNotFoundError} If no entry exists with the given ID.
+     */
+    async deleteEntry(entryId) {
+        const index = this.vault.findIndex((e) => e.id === entryId);
+        if (index === -1)
+            throw new EntryNotFoundError('Entry not found');
+        this.vault.splice(index, 1);
+        await this.persistentStorageManager.save();
+    }
+    /**
+     * Update an existing entry in the vault.
+     * @param updatedEntry - An object containing the updated entry.
+     * @returns A promise that resolves when the entry is updated.
+     * @throws {EntryNotFoundError} If no entry exists with the given ID.
+     */
+    async updateEntry(updatedEntry) {
+        const { id } = updatedEntry;
+        const index = this.vault.findIndex((e) => e.id === id);
+        if (index === -1)
+            throw new EntryNotFoundError('Entry not found');
+        this.vault[index] = updatedEntry;
+        await this.persistentStorageManager.save();
+    }
+    /**
+     * Replace the current vault with a new one.
+     * @param newVault - The new vault data to replace the existing vault.
+     */
+    replaceVault(newVault) {
+        this.vault = newVault;
+    }
+}
+export default VaultDataManager;

package/build/subclasses/VaultOperationsManager.d.mts

@@ -0,0 +1,91 @@
+import type Entry from '../interfaces/Entry.mjs';
+import type { EntryId, EntryMeta, EntryMetaWithToken, NewEntry, Token } from '../interfaces/Entry.mjs';
+import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
+/**
+ * Manages the public operations related to the vault, including adding, deleting, and updating entries.
+ */
+declare class VaultManager {
+    private readonly mediator;
+    /**
+     * Constructs a new instance of VaultManager.
+     * @param mediator - The mediator for accessing other components.
+     */
+    constructor(mediator: TwoFaLibMediator);
+    private get vaultDataManager();
+    private get commandManager();
+    /**
+     * @returns The number of entries in the vault.
+     */
+    get size(): number;
+    /**
+     * Retrieve metadata for a specific entry.
+     * @param entryId - The ID of the entry.
+     * @returns The entry's metadata.
+     * @throws {EntryNotFoundError} If no entry exists with the given ID.
+     */
+    getEntryMeta(entryId: EntryId): EntryMeta;
+    /**
+     * Search for entry ids matching the provided query.
+     * @param query - The search query string.
+     * @returns An array of matching entry IDs.
+     */
+    searchEntries(query: string): EntryId[];
+    /**
+     * Search for entries matching the provided query.
+     * @param query - The search query string.
+     * @param includeTokens - When true, includes current tokens with the metas.
+     * @returns An array of matching entry metas, optionally with tokens.
+     */
+    searchEntriesMetas(query: string, includeTokens: true): EntryMetaWithToken[];
+    /**
+     * @inheritdoc
+     */
+    searchEntriesMetas(query: string, includeTokens?: false): EntryMeta[];
+    /**
+     * Retrieve a list of all entry IDs in the library.
+     * @returns An array of all entry IDs.
+     */
+    listEntries(): EntryId[];
+    /**
+     * Retrieve a list of all entry metas in the library.
+     * @param includeTokens - When true, includes current tokens with the metas.
+     * @returns An array of all entry metas, optionally with tokens.
+     */
+    listEntriesMetas(includeTokens: true): EntryMetaWithToken[];
+    /**
+     * @inheritdoc
+     */
+    listEntriesMetas(includeTokens?: false): EntryMeta[];
+    /**
+     * Generate a time-based one-time password (TOTP) for a specific entry.
+     * @param id - The unique identifier of the entry.
+     * @param timestamp - Optional timestamp to use for token generation (default is current time).
+     * @returns An object containing the token and between which timestamps it is valid
+     * @throws {EntryNotFoundError} If no entry exists with the given ID.
+     * @throws {TokenGenerationError} If token generation fails due to invalid entry data or technical issues.
+     */
+    generateTokenForEntry(id: EntryId, timestamp?: number): Token;
+    /**
+     * Add a new entry to the library.
+     * @param entry - The entry data to add (without an ID, as it will be generated).
+     * @returns A promise that resolves to the newly generated EntryId.
+     * @throws {InvalidCommandError} If the provided entry data is invalid or incomplete.
+     */
+    addEntry(entry: NewEntry): Promise<EntryId>;
+    /**
+     * Delete an existing entry from the library.
+     * @param entryId - The unique identifier of the entry to delete.
+     * @throws {EntryNotFoundError} If no entry exists with the given ID.
+     */
+    deleteEntry(entryId: EntryId): Promise<void>;
+    /**
+     * Update an existing entry in the library.
+     * @param entryId - The unique identifier of the entry to update.
+     * @param updates - An object containing the fields to update and their new values.
+     * @returns A promise that resolves to the updated entry's metadata.
+     * @throws {EntryNotFoundError} If no entry exists with the given ID.
+     * @throws {InvalidCommandError} If the update data is invalid or would result in an invalid entry.
+     */
+    updateEntry(entryId: EntryId, updates: Partial<Omit<Entry, 'id'>>): Promise<EntryMeta>;
+}
+export default VaultManager;

package/build/subclasses/VaultOperationsManager.mjs

@@ -0,0 +1,163 @@
+import { v4 as genUuidV4 } from 'uuid';
+import AddEntryCommand from '../Command/commands/AddEntryCommand.mjs';
+import DeleteEntryCommand from '../Command/commands/DeleteEntryCommand.mjs';
+import UpdateEntryCommand from '../Command/commands/UpdateEntryCommand.mjs';
+import { EntryNotFoundError } from '../TwoFALibError.mjs';
+const getMetaForEntry = (entry) => ({
+    id: entry.id,
+    name: entry.name,
+    issuer: entry.issuer,
+    type: entry.type,
+    addedAt: entry.addedAt,
+    updatedAt: entry.updatedAt,
+});
+/**
+ * Manages the public operations related to the vault, including adding, deleting, and updating entries.
+ */
+class VaultManager {
+    /**
+     * Constructs a new instance of VaultManager.
+     * @param mediator - The mediator for accessing other components.
+     */
+    constructor(mediator) {
+        this.mediator = mediator;
+    }
+    get vaultDataManager() {
+        return this.mediator.getComponent('vaultDataManager');
+    }
+    get commandManager() {
+        return this.mediator.getComponent('commandManager');
+    }
+    /**
+     * @returns The number of entries in the vault.
+     */
+    get size() {
+        return this.vaultDataManager.size;
+    }
+    /**
+     * Retrieve metadata for a specific entry.
+     * @param entryId - The ID of the entry.
+     * @returns The entry's metadata.
+     * @throws {EntryNotFoundError} If no entry exists with the given ID.
+     */
+    getEntryMeta(entryId) {
+        return getMetaForEntry(this.vaultDataManager.getFullEntry(entryId));
+    }
+    /**
+     * Search for entry ids matching the provided query.
+     * @param query - The search query string.
+     * @returns An array of matching entry IDs.
+     */
+    searchEntries(query) {
+        const lowercaseQuery = query.toLowerCase();
+        const entries = this.vaultDataManager.getAllEntries();
+        return entries
+            .filter((entry) => entry.name.toLowerCase().includes(lowercaseQuery) ||
+            entry.issuer.toLowerCase().includes(lowercaseQuery))
+            .map((entry) => entry.id);
+    }
+    /**
+     * @inheritdoc
+     */
+    searchEntriesMetas(query, includeTokens) {
+        const lowercaseQuery = query.toLowerCase();
+        const entries = this.vaultDataManager.getAllEntries();
+        return entries
+            .filter((entry) => entry.name.toLowerCase().includes(lowercaseQuery) ||
+            entry.issuer.toLowerCase().includes(lowercaseQuery))
+            .map((entry) => {
+            const meta = getMetaForEntry(entry);
+            if (includeTokens) {
+                return {
+                    ...meta,
+                    token: this.generateTokenForEntry(entry.id),
+                };
+            }
+            return meta;
+        });
+    }
+    /**
+     * Retrieve a list of all entry IDs in the library.
+     * @returns An array of all entry IDs.
+     */
+    listEntries() {
+        return this.vaultDataManager.getAllEntries().map((entry) => entry.id);
+    }
+    /**
+     * @inheritdoc
+     */
+    listEntriesMetas(includeTokens) {
+        const entries = this.vaultDataManager.getAllEntries();
+        return entries.map((entry) => {
+            const meta = getMetaForEntry(entry);
+            if (includeTokens) {
+                return {
+                    ...meta,
+                    token: this.generateTokenForEntry(entry.id),
+                };
+            }
+            return meta;
+        });
+    }
+    /**
+     * Generate a time-based one-time password (TOTP) for a specific entry.
+     * @param id - The unique identifier of the entry.
+     * @param timestamp - Optional timestamp to use for token generation (default is current time).
+     * @returns An object containing the token and between which timestamps it is valid
+     * @throws {EntryNotFoundError} If no entry exists with the given ID.
+     * @throws {TokenGenerationError} If token generation fails due to invalid entry data or technical issues.
+     */
+    generateTokenForEntry(id, timestamp) {
+        return this.vaultDataManager.generateTokenForEntry(id, timestamp);
+    }
+    /**
+     * Add a new entry to the library.
+     * @param entry - The entry data to add (without an ID, as it will be generated).
+     * @returns A promise that resolves to the newly generated EntryId.
+     * @throws {InvalidCommandError} If the provided entry data is invalid or incomplete.
+     */
+    async addEntry(entry) {
+        const newId = genUuidV4();
+        const newEntry = {
+            ...entry,
+            id: newId,
+            addedAt: Date.now(),
+            updatedAt: null,
+        };
+        const command = AddEntryCommand.create(newEntry);
+        await this.commandManager.execute(command);
+        return newId;
+    }
+    /**
+     * Delete an existing entry from the library.
+     * @param entryId - The unique identifier of the entry to delete.
+     * @throws {EntryNotFoundError} If no entry exists with the given ID.
+     */
+    async deleteEntry(entryId) {
+        const command = DeleteEntryCommand.create({ entryId });
+        await this.commandManager.execute(command);
+    }
+    /**
+     * Update an existing entry in the library.
+     * @param entryId - The unique identifier of the entry to update.
+     * @param updates - An object containing the fields to update and their new values.
+     * @returns A promise that resolves to the updated entry's metadata.
+     * @throws {EntryNotFoundError} If no entry exists with the given ID.
+     * @throws {InvalidCommandError} If the update data is invalid or would result in an invalid entry.
+     */
+    async updateEntry(entryId, updates) {
+        if (Object.keys(updates).includes('id')) {
+            throw new EntryNotFoundError("Can't update id");
+        }
+        const oldEntry = this.vaultDataManager.getFullEntry(entryId);
+        const updatedEntry = { ...oldEntry, ...updates };
+        const command = UpdateEntryCommand.create({
+            entryId,
+            oldEntry,
+            updatedEntry,
+        });
+        await this.commandManager.execute(command);
+        return getMetaForEntry(updatedEntry);
+    }
+}
+export default VaultManager;

package/build/utils/constants.d.mts

@@ -0,0 +1,2 @@
+export declare const SUPPORTED_ALGORITHMS: readonly ["SHA-1", "SHA-256", "SHA-512"];
+export type SupportedAlgorithmsType = (typeof SUPPORTED_ALGORITHMS)[number];

package/build/utils/constants.mjs

@@ -0,0 +1 @@
+export const SUPPORTED_ALGORITHMS = ['SHA-1', 'SHA-256', 'SHA-512'];

package/build/utils/creationUtils.d.mts

@@ -0,0 +1,43 @@
+import type { ZxcvbnResult } from '@zxcvbn-ts/core';
+import type CryptoLib from '../interfaces/CryptoLib.mjs';
+import type { Passphrase } from '../interfaces/CryptoLib.mjs';
+import type { DeviceType } from '../interfaces/SyncTypes.mjs';
+import TwoFaLib from '../TwoFaLib.mjs';
+import LibraryLoader from '../subclasses/LibraryLoader.mjs';
+import type { LockedRepresentationString } from '../interfaces/Vault.mjs';
+import type { PassphraseExtraDict } from '../interfaces/PassphraseExtraDict.js';
+/**
+ * Evaluates the strength of a passphrase.
+ * @param libraryLoader - An instance of LibraryLoader.
+ * @param passphrase - The passphrase to evaluate.
+ * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @returns Promise resolving to the passphrase strength result.
+ */
+export declare const getPassphraseStrength: (libraryLoader: LibraryLoader, passphrase: Passphrase, passphraseExtraDict: PassphraseExtraDict) => Promise<ZxcvbnResult>;
+/**
+ * Validates the strength of a passphrase.
+ * @param libraryLoader - An instance of LibraryLoader.
+ * @param passphrase - The passphrase to validate.
+ * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @throws {InitializationError} If the passphrase is too weak.
+ */
+export declare const validatePassphraseStrength: (libraryLoader: LibraryLoader, passphrase: Passphrase, passphraseExtraDict: PassphraseExtraDict) => Promise<void>;
+/**
+ * Returns utility functions useful in creating a new twoFaLib vault
+ * @param cryptoLib - An instance of CryptoLib that is compatible with the environment.
+ * @param deviceType - A unique identifier for this device type (e.g. 2fa-cli).
+ * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param serverUrl - The server URL for syncing.
+ * @returns An object with methods to evaluate passphrase strength and create a new TwoFaLib vault.
+ */
+export declare const getTwoFaLibVaultCreationUtils: (cryptoLib: CryptoLib, deviceType: DeviceType, passphraseExtraDict: PassphraseExtraDict, serverUrl?: string) => {
+    getPassphraseStrength: (passphrase: Passphrase, passphraseExtraDict: PassphraseExtraDict) => Promise<ZxcvbnResult>;
+    createNewTwoFaLibVault: (passphrase: Passphrase) => Promise<{
+        twoFaLib: TwoFaLib;
+        publicKey: import("../interfaces/CryptoLib.mjs").PublicKey;
+        encryptedPrivateKey: import("../interfaces/CryptoLib.mjs").EncryptedPrivateKey;
+        encryptedSymmetricKey: import("../interfaces/CryptoLib.mjs").EncryptedSymmetricKey;
+        salt: import("../interfaces/CryptoLib.mjs").Salt;
+    }>;
+    loadTwoFaLibFromLockedRepesentation: (lockedRepresentationString: LockedRepresentationString, passphrase: Passphrase) => Promise<TwoFaLib>;
+};

package/build/utils/creationUtils.mjs

@@ -0,0 +1,125 @@
+import { v4 as genUuidV4 } from 'uuid';
+import TwoFaLib from '../TwoFaLib.mjs';
+import { InitializationError, TwoFALibError } from '../TwoFALibError.mjs';
+import LibraryLoader from '../subclasses/LibraryLoader.mjs';
+/**
+ * Evaluates the strength of a passphrase.
+ * @param libraryLoader - An instance of LibraryLoader.
+ * @param passphrase - The passphrase to evaluate.
+ * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @returns Promise resolving to the passphrase strength result.
+ */
+export const getPassphraseStrength = async (libraryLoader, passphrase, passphraseExtraDict) => {
+    const zxcvbn = await libraryLoader.getZxcvbn();
+    return zxcvbn(passphrase, [
+        'twofactor',
+        'authentication',
+        'token',
+        '2fa',
+        'otp',
+        'tfa',
+        'mfa',
+        'security',
+        'login',
+        'verify',
+        'app',
+        'yubikey',
+        'secret',
+        'vault',
+        'encrypt',
+        'decrypt',
+        'qr',
+        'timebased',
+        'hmac',
+        'key',
+        'trust',
+        'secure',
+        ...passphraseExtraDict,
+    ]);
+};
+/**
+ * Validates the strength of a passphrase.
+ * @param libraryLoader - An instance of LibraryLoader.
+ * @param passphrase - The passphrase to validate.
+ * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @throws {InitializationError} If the passphrase is too weak.
+ */
+export const validatePassphraseStrength = async (libraryLoader, passphrase, passphraseExtraDict) => {
+    const passphraseStrength = await getPassphraseStrength(libraryLoader, passphrase, passphraseExtraDict);
+    if (passphraseStrength.score < 3) {
+        throw new TwoFALibError('Passphrase is too weak');
+    }
+};
+/**
+ * Creates a new TwoFaLib vault.
+ * @param libraryLoader - An instance of LibraryLoader.
+ * @param deviceType - A unique identifier for the device type e.g. 2fa-cli.
+ * @param serverUrl - The server URL for syncing.
+ * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param passphrase - The passphrase to be used to encrypt the private key.
+ * @returns Promise resolving to an object containing the newly created TwoFaLib instance and related data.
+ */
+const createNewTwoFaLibVault = async (libraryLoader, deviceType, serverUrl, passphraseExtraDict, passphrase) => {
+    const cryptoLib = libraryLoader.getCryptoLib();
+    const { publicKey, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, } = await cryptoLib.createKeys(passphrase);
+    await validatePassphraseStrength(libraryLoader, passphrase, passphraseExtraDict);
+    const deviceId = genUuidV4();
+    const twoFaLib = new TwoFaLib(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, deviceId, [], {
+        serverUrl,
+        devices: [],
+        commandSendQueue: [],
+    });
+    return {
+        twoFaLib,
+        publicKey,
+        encryptedPrivateKey,
+        encryptedSymmetricKey,
+        salt,
+    };
+};
+/**
+ * Loads the library state from a previously locked representation.
+ * @param libraryLoader - An instance of LibraryLoader.
+ * @param deviceType - A unique identifier for this device type (e.g. 2fa-cli).
+ * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param lockedRepresentationString - The string representation of the locked library state representation.
+ * @param passphrase - The passphrase for decrypting the keys.
+ * @returns A promise that resolves when loading is complete.
+ * @throws {InitializationError} If loading fails due to invalid or corrupted data.
+ */
+const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, passphraseExtraDict, lockedRepresentationString, passphrase) => {
+    const cryptoLib = libraryLoader.getCryptoLib();
+    const lockedRepresentation = JSON.parse(lockedRepresentationString);
+    if (!lockedRepresentation ||
+        !lockedRepresentation.encryptedPrivateKey ||
+        !lockedRepresentation.encryptedSymmetricKey ||
+        !lockedRepresentation.salt ||
+        !lockedRepresentation.encryptedVaultState) {
+        throw new InitializationError('lockedRepresentation is incomplete or corrupted');
+    }
+    const { privateKey, symmetricKey, publicKey } = await cryptoLib.decryptKeys(lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, passphrase);
+    const vaultState = JSON.parse(await cryptoLib.decryptSymmetric(symmetricKey, lockedRepresentation.encryptedVaultState));
+    if (!vaultState ||
+        !vaultState.deviceId ||
+        !vaultState.sync?.commandSendQueue ||
+        !vaultState.sync?.devices) {
+        throw new InitializationError('encryptedVaultState is incomplete or corrupted');
+    }
+    return new TwoFaLib(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, publicKey, vaultState.deviceId, vaultState.vault, vaultState.sync);
+};
+/**
+ * Returns utility functions useful in creating a new twoFaLib vault
+ * @param cryptoLib - An instance of CryptoLib that is compatible with the environment.
+ * @param deviceType - A unique identifier for this device type (e.g. 2fa-cli).
+ * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param serverUrl - The server URL for syncing.
+ * @returns An object with methods to evaluate passphrase strength and create a new TwoFaLib vault.
+ */
+export const getTwoFaLibVaultCreationUtils = (cryptoLib, deviceType, passphraseExtraDict, serverUrl) => {
+    const libraryLoader = new LibraryLoader(cryptoLib);
+    return {
+        getPassphraseStrength: getPassphraseStrength.bind(null, libraryLoader),
+        createNewTwoFaLibVault: createNewTwoFaLibVault.bind(null, libraryLoader, deviceType, serverUrl, passphraseExtraDict),
+        loadTwoFaLibFromLockedRepesentation: loadTwoFaLibFromLockedRepesentation.bind(null, libraryLoader, deviceType, passphraseExtraDict),
+    };
+};

package/build/utils/exportImportUtils.d.mts

@@ -0,0 +1,53 @@
+import type { NewEntry } from '../interfaces/Entry.mjs';
+import type Entry from '../interfaces/Entry.mjs';
+import type { EntryId } from '../interfaces/Entry.mjs';
+/**
+ * Parses an OTP URI and extracts the relevant information to create a new entry.
+ * @param UrlParser - The URL parsing library.
+ * @param otpUri - The OTP URI to parse.
+ * @returns An object representing the new entry.
+ * @throws ExportImportError if the URI is invalid or contains unsupported features.
+ */
+export declare const parseOtpUri: (UrlParser: typeof import("whatwg-url"), otpUri: string) => NewEntry;
+/**
+ * Generates an HTML page with QR codes for the provided OTP entries.
+ * @param qrGeneratorLib - The QR code generation library.
+ * @param entries - An array of OTP entries.
+ * @returns A promise that resolves to the HTML string.
+ */
+export declare const generateHtmlExport: (qrGeneratorLib: typeof import("qrcode"), entries: Entry[]) => Promise<string>;
+/**
+ * Generates a text export of OTP URIs for the provided entries.
+ * @param entries - An array of OTP entries.
+ * @returns A string containing the OTP URIs, one per line.
+ */
+export declare const generateTextExport: (entries: Entry[]) => string;
+/**
+ * Processes the lines of a text file containing OTP URIs and returns 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.
+ * @param lines - An array of strings, each containing an OTP URI.
+ * @param importFromUri - A function that takes a URI and returns a promise that resolves to the EntryId.
+ * @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.
+ */
+export declare const processImportLines: (lines: string[], importFromUri: (uri: string) => Promise<EntryId>) => Promise<{
+    lineNr: number;
+    entryId: EntryId | null;
+    error: unknown;
+}[]>;
+/**
+ * Encrypts the given data using OpenPGP.
+ * @param openPgpLib - The OpenPGP library.
+ * @param data - The data to encrypt.
+ * @param password - The password to use for encryption.
+ * @returns A promise that resolves to the encrypted data.
+ */
+export declare const encryptExport: (openPgpLib: typeof import("openpgp"), data: string, password: string) => Promise<string>;
+/**
+ * Decrypts the given data using OpenPGP.
+ * @param openPgpLib - The OpenPGP library.
+ * @param data - The data to decrypt.
+ * @param password - The password to use for decryption.
+ * @returns A promise that resolves to the decrypted data.
+ */
+export declare const decryptExport: (openPgpLib: typeof import("openpgp"), data: string, password: string) => Promise<string>;