/// <reference types="node" resolution-mode="require"/>
import type { ContextTimed, ContextTimedInput } from '@matrixai/contexts';
import type { DBTransaction, LevelPath } from '@matrixai/db';
import type { VaultId, VaultName, VaultActions, VaultIdString, VaultIdEncoded } from './types.js';
import type { Vault } from './Vault.js';
import type { FileSystem } from '../types.js';
import type { NodeId } from '../ids/types.js';
import type KeyRing from '../keys/KeyRing.js';
import type NodeManager from '../nodes/NodeManager.js';
import type GestaltGraph from '../gestalts/GestaltGraph.js';
import type NotificationsManager from '../notifications/NotificationsManager.js';
import type ACL from '../acl/ACL.js';
import type { PolykeyWorkerManager } from '../workers/types.js';
import type { RemoteInfo } from './VaultInternal.js';
import type { VaultAction } from './types.js';
import type { AgentClientManifest } from '../nodes/agent/callers/index.js';
import { DB } from '@matrixai/db';
import { EncryptedFS } from 'encryptedfs';
import { createDestroyStartStop } from '@matrixai/async-init';
import { LockBox, RWLockWriter } from '@matrixai/async-locks';
import Logger from '@matrixai/logger';
import VaultInternal from './VaultInternal.js';
/**
 * Object map pattern for each vault.
 */
type VaultMap = Map<VaultIdString, VaultInternal>;
type VaultList = Map<VaultName, VaultId>;
type VaultMetadata = {
    dirty: boolean;
    vaultName: VaultName;
    remoteInfo?: RemoteInfo;
};
interface VaultManager extends createDestroyStartStop.CreateDestroyStartStop {
}
declare class VaultManager {
    static createVaultManager({ vaultsPath, db, acl, keyRing, nodeManager, gestaltGraph, notificationsManager, fs, logger, fresh, }: {
        vaultsPath: string;
        db: DB;
        acl: ACL;
        keyRing: KeyRing;
        nodeManager: NodeManager<AgentClientManifest>;
        gestaltGraph: GestaltGraph;
        notificationsManager: NotificationsManager;
        fs?: FileSystem;
        logger?: Logger;
        fresh?: boolean;
    }): Promise<VaultManager>;
    readonly vaultsPath: string;
    readonly efsPath: string;
    protected fs: FileSystem;
    protected logger: Logger;
    protected db: DB;
    protected acl: ACL;
    protected keyRing: KeyRing;
    protected nodeManager: NodeManager<AgentClientManifest>;
    protected gestaltGraph: GestaltGraph;
    protected notificationsManager: NotificationsManager;
    protected vaultsDbPath: LevelPath;
    protected vaultsNamesDbPath: LevelPath;
    protected vaultMap: VaultMap;
    protected vaultLocks: LockBox<RWLockWriter>;
    protected vaultKey: Buffer;
    protected efsDb: DB;
    protected efs: EncryptedFS;
    protected vaultIdGenerator: () => VaultId;
    constructor({ vaultsPath, db, acl, keyRing, nodeManager, gestaltGraph, notificationsManager, fs, logger, }: {
        vaultsPath: string;
        db: DB;
        acl: ACL;
        keyRing: KeyRing;
        nodeManager: NodeManager<AgentClientManifest>;
        gestaltGraph: GestaltGraph;
        notificationsManager: NotificationsManager;
        fs: FileSystem;
        logger: Logger;
    });
    start({ fresh, }?: {
        fresh?: boolean;
    }): Promise<void>;
    stop(): Promise<void>;
    destroy(): Promise<void>;
    setWorkerManager(workerManager: PolykeyWorkerManager): void;
    unsetWorkerManager(): void;
    /**
     * Constructs a new Vault instance with a given name and stores it in memory.
     */
    createVault(vaultName: VaultName, tran?: DBTransaction, ctx?: Partial<ContextTimedInput>): Promise<VaultId>;
    /**
     * Retrieves the vault metadata using the VaultId and parses it to return the
     * associated vault name.
     */
    getVaultMeta(vaultId: VaultId, tran?: DBTransaction): Promise<VaultMetadata | undefined>;
    /**
     * Removes the metadata and EFS state of a vault using a given VaultId.
     */
    destroyVault(vaultId: VaultId, tran?: DBTransaction, ctx?: Partial<ContextTimed>): Promise<void>;
    /**
     * Removes a vault from the vault map.
     */
    closeVault(vaultId: VaultId, tran?: DBTransaction, ctx?: Partial<ContextTimedInput>): Promise<void>;
    /**
     * Lists the vault name and associated VaultId of all the stored vaults.
     */
    listVaults(ctx?: Partial<ContextTimed>, tran?: DBTransaction): Promise<VaultList>;
    /**
     * Changes the vault name metadata of a VaultId.
     */
    renameVault(vaultId: VaultId, newVaultName: VaultName, tran?: DBTransaction): Promise<void>;
    /**
     * Retrieves the VaultId associated with a vault name.
     */
    getVaultId(vaultName: VaultName, tran?: DBTransaction): Promise<VaultId | undefined>;
    /**
     * Retrieves the vault name associated with a VaultId.
     */
    getVaultName(vaultId: VaultId, tran?: DBTransaction): Promise<VaultName | undefined>;
    /**
     * Returns a dictionary of VaultActions for each node
     */
    getVaultPermission(vaultId: VaultId, tran?: DBTransaction): Promise<Record<NodeId, VaultActions>>;
    /**
     * Sets clone, pull and scan permissions of a vault for a gestalt and send a
     * notification to this gestalt.
     */
    shareVault(vaultId: VaultId, nodeId: NodeId, tran?: DBTransaction): Promise<void>;
    /**
     * Unsets clone, pull and scan permissions of a vault for a gestalt.
     */
    unshareVault(vaultId: VaultId, nodeId: NodeId, tran?: DBTransaction): Promise<void>;
    /**
     * Clones the contents of a remote vault into a new local
     * vault instance
     */
    cloneVault(nodeId: NodeId, vaultNameOrId: VaultId | VaultName, tran?: DBTransaction, ctx?: Partial<ContextTimedInput>): Promise<VaultId>;
    /**
     * Pulls the contents of a remote vault into an existing vault instance.
     */
    pullVault({ vaultId, pullNodeId, pullVaultNameOrId, }: {
        vaultId: VaultId;
        pullNodeId?: NodeId;
        pullVaultNameOrId?: VaultId | VaultName;
    }, tran?: DBTransaction, ctx?: Partial<ContextTimed>): Promise<void>;
    /**
     * Handler for receiving http GET requests when being cloned or pulled from.
     */
    handleInfoRequest(vaultId: VaultId, tran?: DBTransaction, ctx?: Partial<ContextTimedInput>): AsyncGenerator<Buffer, void, void>;
    /**
     * Handler for receiving http POST requests when being cloned or pulled from.
     */
    handlePackRequest(vaultId: VaultId, body: Array<Buffer>, tran?: DBTransaction, ctx?: Partial<ContextTimedInput>): AsyncGenerator<Buffer, void, void>;
    /**
     * Retrieves all the vaults for a peer's node.
     */
    scanVaults(targetNodeId: NodeId, ctx?: Partial<ContextTimedInput>): AsyncGenerator<{
        vaultName: VaultName;
        vaultIdEncoded: VaultIdEncoded;
        vaultPermissions: VaultAction[];
    }>;
    /**
     * Returns all the shared vaults for a NodeId.
     */
    handleScanVaults(nodeId: NodeId, tran?: DBTransaction, ctx?: Partial<ContextTimedInput>): AsyncGenerator<{
        vaultId: VaultId;
        vaultName: VaultName;
        vaultPermissions: VaultAction[];
    }>;
    protected generateVaultId(): Promise<VaultId>;
    protected getVault(vaultId: VaultId, tran: DBTransaction, ctx: ContextTimed): Promise<VaultInternal>;
    /**
     * Takes a function and runs it with the listed vaults. Locking is handled
     * automatically.
     * @param vaultIds List of vault ID for vaults you wish to use
     * @param f Function you wish to run with the provided vaults
     * @param tran
     * @param ctx
     */
    withVaults<T>(vaultIds: VaultId[], f: (...args: Vault[]) => Promise<T>, tran?: DBTransaction, ctx?: Partial<ContextTimedInput>): Promise<T>;
    /**
     * Takes a generator and runs it with the listed vaults. Locking is handled
     * automatically.
     * @param vaultIds List of vault ID for vaults you wish to use
     * @param g Generator you wish to run with the provided vaults
     * @param tran
     * @param ctx
     */
    withVaultsG<T, TReturn, TNext>(vaultIds: Array<VaultId>, g: (...args: Array<Vault>) => AsyncGenerator<T, TReturn, TNext>, tran?: DBTransaction, ctx?: Partial<ContextTimedInput>): AsyncGenerator<T, TReturn, TNext>;
    protected setupKey(tran: DBTransaction): Promise<Buffer>;
    protected existsEFS(): Promise<boolean>;
}
export default VaultManager;