@hazae41/kdbx/out/mods/kdbx/mod.d.ts

Rust-like KeePass (KDBX 4) file format for TypeScript

export * from "./dictionary/mod.ts";
export * from "./headers/mod.ts";
import { Unknown } from "@hazae41/binary";
import { Cursor } from "@hazae41/cursor";
import { Inner, Outer } from "./headers/mod.ts";
export declare class PasswordKey {
    #private;
    readonly value: Unknown<ArrayBuffer, 32>;
    constructor(value: Unknown<ArrayBuffer, 32>);
    static digestOrThrow(password: Uint8Array<ArrayBuffer>): Promise<PasswordKey>;
}
export declare class CompositeKey {
    #private;
    readonly value: Unknown<ArrayBuffer, 32>;
    constructor(value: Unknown<ArrayBuffer, 32>);
    static digestOrThrow(password: PasswordKey): Promise<CompositeKey>;
}
export declare class DerivedKey {
    #private;
    readonly value: Unknown<ArrayBuffer, 32>;
    constructor(value: Unknown<ArrayBuffer, 32>);
}
export declare class PreMasterKey {
    #private;
    readonly seed: Unknown<ArrayBuffer, 32>;
    readonly hash: DerivedKey;
    constructor(seed: Unknown<ArrayBuffer, 32>, hash: DerivedKey);
    sizeOrThrow(): number;
    writeOrThrow(cursor: Cursor<ArrayBuffer>): void;
    digestOrThrow(): Promise<MasterKey>;
}
export declare class MasterKey {
    #private;
    readonly value: Unknown<ArrayBuffer, 32>;
    constructor(value: Unknown<ArrayBuffer, 32>);
}
export declare class PreHmacMasterKey {
    #private;
    readonly seed: Unknown<ArrayBuffer, 32>;
    readonly hash: DerivedKey;
    constructor(seed: Unknown<ArrayBuffer, 32>, hash: DerivedKey);
    sizeOrThrow(): number;
    writeOrThrow(cursor: Cursor<ArrayBuffer>): void;
    digestOrThrow(): Promise<HmacMasterKey>;
}
export declare class HmacMasterKey {
    #private;
    readonly bytes: Unknown<ArrayBuffer, 64>;
    constructor(bytes: Unknown<ArrayBuffer, 64>);
}
export declare class MasterKeys {
    #private;
    readonly encrypter: MasterKey;
    readonly authifier: HmacMasterKey;
    constructor(encrypter: MasterKey, authifier: HmacMasterKey);
}
export declare namespace Database {
    class Decrypted {
        readonly outer: Outer.MagicAndVersionAndHeadersWithBytesWithHashAndHmacWithKeys;
        readonly inner: Inner.HeadersAndContentWithBytes;
        constructor(outer: Outer.MagicAndVersionAndHeadersWithBytesWithHashAndHmacWithKeys, inner: Inner.HeadersAndContentWithBytes);
        encryptOrThrow(composite: CompositeKey): Promise<Encrypted>;
    }
    class Encrypted {
        readonly outer: Outer.MagicAndVersionAndHeadersWithBytesWithHashAndHmac;
        readonly inner: Blocks;
        constructor(outer: Outer.MagicAndVersionAndHeadersWithBytesWithHashAndHmac, inner: Blocks);
        sizeOrThrow(): number;
        writeOrThrow(cursor: Cursor<ArrayBuffer>): void;
        cloneOrThrow(): Encrypted;
        decryptOrThrow(composite: CompositeKey): Promise<Decrypted>;
    }
    namespace Encrypted {
        function readOrThrow(cursor: Cursor<ArrayBuffer>): Encrypted;
    }
}
export declare class Blocks {
    readonly blocks: BlockWithIndex[];
    constructor(blocks: BlockWithIndex[]);
    sizeOrThrow(): number;
    writeOrThrow(cursor: Cursor<ArrayBuffer>): void;
    cloneOrThrow(): Blocks;
}
export declare namespace Blocks {
    function readOrThrow(cursor: Cursor<ArrayBuffer>): Blocks;
}
export declare class BlockWithIndexPreHmacData {
    readonly index: bigint;
    readonly block: Unknown<ArrayBuffer>;
    constructor(index: bigint, block: Unknown<ArrayBuffer>);
    sizeOrThrow(): number;
    writeOrThrow(cursor: Cursor<ArrayBuffer>): void;
}
export declare class BlockWithIndex {
    readonly index: bigint;
    readonly block: Block;
    constructor(index: bigint, block: Block);
    sizeOrThrow(): number;
    writeOrThrow(cursor: Cursor<ArrayBuffer>): void;
    cloneOrThrow(): BlockWithIndex;
    verifyOrThrow(keys: MasterKeys): Promise<void>;
}
export declare namespace BlockWithIndex {
    function fromOrThrow(keys: MasterKeys, index: bigint, data: Uint8Array<ArrayBuffer>): Promise<BlockWithIndex>;
}
export declare class Block {
    readonly hmac: Unknown<ArrayBuffer, 32>;
    readonly data: Unknown<ArrayBuffer>;
    constructor(hmac: Unknown<ArrayBuffer, 32>, data: Unknown<ArrayBuffer>);
    sizeOrThrow(): number;
    writeOrThrow(cursor: Cursor<ArrayBuffer>): void;
    cloneOrThrow(): Block;
}
export declare namespace Block {
    function readOrThrow(cursor: Cursor<ArrayBuffer>): Block;
}