From ac84fc6c7f22b49cfe4066d080109e02fdf76db9 Mon Sep 17 00:00:00 2001
From: Lucas <git@roang.info>
Date: Fri, 9 Nov 2018 22:02:35 +0100
Subject: [PATCH] Add initial definitions for kdbxweb

---
 types/kdbxweb/index.d.ts       | 461 +++++++++++++++++++++++++++++++++
 types/kdbxweb/kdbxweb-tests.ts |  18 ++
 types/kdbxweb/tsconfig.json    |  23 ++
 types/kdbxweb/tslint.json      |   1 +
 4 files changed, 503 insertions(+)
 create mode 100644 types/kdbxweb/index.d.ts
 create mode 100644 types/kdbxweb/kdbxweb-tests.ts
 create mode 100644 types/kdbxweb/tsconfig.json
 create mode 100644 types/kdbxweb/tslint.json

diff --git a/types/kdbxweb/index.d.ts b/types/kdbxweb/index.d.ts
new file mode 100644
index 0000000000..2787ba7a1f
--- /dev/null
+++ b/types/kdbxweb/index.d.ts
@@ -0,0 +1,461 @@
+// Type definitions for kdbxweb 1.2
+// Project: https://github.com/keeweb/kdbxweb#readme
+// Definitions by: Roang-zero1 <https://github.com/Roang-zero1>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import Crypto from "crypto";
+
+/*~ If this module is a UMD module that exposes a global variable 'myLib' when
+ *~ loaded outside a module loader environment, declare that global here.
+ *~ Otherwise, delete this declaration.
+ */
+export as namespace kdbxweb;
+
+export interface Settings {
+    binaries: boolean;
+    customIcons: boolean;
+    historyRules: boolean;
+}
+
+export interface ObjectMap {
+    objects: object[];
+    remote: object[];
+    deleted: object[];
+}
+
+export interface editingState {
+    added: [Date];
+    deleted: [Date];
+}
+
+export interface editingStateDict {
+    meta: editingState;
+    [uuid: string]: editingState;
+}
+
+export class Credentials {
+    constructor(
+        password: ProtectedValue,
+        keyFile: string | ArrayBuffer | Uint8Array
+    );
+
+    getHash(): Promise<ArrayBuffer>;
+
+    setKeyFile(keyFile: ArrayBuffer | Uint8Array | null): Promise<void>;
+
+    setPassword(password: ProtectedValue | null): Promise<void>;
+
+    static createKeyFileWithHash(hash: string): Uint8Array;
+
+    static createRandomKeyFile(): Uint8Array;
+}
+
+export class Int64 {
+    constructor(lo: number, hi: number);
+
+    valueOf(): number;
+
+    static from(value: number): Int64;
+}
+
+export class Kdbx {
+    constructor();
+
+    addDeletedObject(uuid: KdbxUuid, dt: Date): void;
+
+    cleanup(settings: Settings): void;
+
+    createBinary(
+        value: ProtectedValue | ArrayBuffer
+    ): Promise<ProtectedValue | ArrayBuffer>;
+
+    createDefaultGroup(): void;
+
+    createEntry(group: Group): Entry;
+
+    createGroup(group: Group, name: string): Group;
+
+    createRecycleBin(): void;
+
+    getDefaultGroup(): Group;
+
+    getGroup(uuid: KdbxUuid | string, parentGroup: Group): Group | undefined;
+
+    getLocalEditState(): editingStateDict;
+
+    merge(remote: Kdbx): void;
+
+    move(object: Entry | Group, toGroup: Group, atIndex: number): void;
+
+    remove(object: Entry | Group): void;
+
+    removeLocalEditState(): void;
+
+    save(): Promise<ArrayBuffer>;
+
+    saveXml(): Promise<string>;
+
+    setLocalEditState(editingState: editingStateDict): void;
+
+    upgrade(): void;
+
+    static create(credentials: Credentials, name: string): Kdbx;
+
+    static load(data: ArrayBuffer, credentials: Credentials): Promise<Kdbx>;
+
+    static loadXml(data: string, credentials: Credentials): Promise<Kdbx>;
+}
+
+export class KdbxError {
+    constructor(code: number, message: string);
+
+    // Native method; no parameter or return type inference available
+    toString(): string;
+}
+
+export class KdbxUuid {
+    constructor(ab: string | ArrayBuffer);
+
+    equals(other: KdbxUuid): boolean;
+
+    toBytes(): Uint8Array | undefined;
+
+    toString(): string;
+
+    valueOf(): string | undefined;
+
+    static random(): KdbxUuid;
+}
+
+export class ProtectedValue {
+    constructor(value: ArrayBuffer, salt: ArrayBuffer);
+
+    clone(): ProtectedValue;
+
+    getBinary(): Uint8Array;
+
+    getHash(): Promise<ArrayBuffer>;
+
+    getText(): string;
+
+    includes(str: string): boolean;
+
+    setSalt(newSalt: ArrayBuffer): void;
+
+    toString(): string;
+
+    static fromBinary(binary: ArrayBuffer): ProtectedValue;
+
+    static fromString(str: string): ProtectedValue;
+}
+
+export class VarDictionary {
+    constructor();
+
+    get(key: string): any;
+
+    keys(): string[];
+
+    remove(key: string): void;
+
+    set(key: string, type: number, value: any): void;
+
+    write(stm: BinaryStream): void;
+
+    static ValueType: {
+        Bool: number;
+        Bytes: number;
+        Int32: number;
+        Int64: number;
+        String: number;
+        UInt32: number;
+        UInt64: number;
+    };
+
+    static read(stm: BinaryStream): VarDictionary;
+}
+
+export const Consts: {
+    AutoTypeObfuscationOptions: {
+        None: number;
+        UseClipboard: number;
+    };
+    CipherId: {
+        Aes: string;
+        ChaCha20: string;
+    };
+    CompressionAlgorithm: {
+        GZip: number;
+        None: number;
+    };
+    CrsAlgorithm: {
+        ArcFourVariant: number;
+        ChaCha20: number;
+        Null: number;
+        Salsa20: number;
+    };
+    Defaults: {
+        HistoryMaxItems: number;
+        HistoryMaxSize: number;
+        KeyEncryptionRounds: number;
+        MntncHistoryDays: number;
+        RecycleBinName: string;
+    };
+    ErrorCodes: {
+        BadSignature: string;
+        FileCorrupt: string;
+        InvalidArg: string;
+        InvalidKey: string;
+        InvalidVersion: string;
+        MergeError: string;
+        NotImplemented: string;
+        Unsupported: string;
+    };
+    Icons: {
+        Apple: number;
+        Archive: number;
+        BlackBerry: number;
+        Book: number;
+        CDRom: number;
+        Certificate: number;
+        Checked: number;
+        ClipboardReady: number;
+        Clock: number;
+        Configuration: number;
+        Console: number;
+        Digicam: number;
+        Disk: number;
+        Drive: number;
+        DriveWindows: number;
+        EMail: number;
+        EMailBox: number;
+        EMailSearch: number;
+        Energy: number;
+        EnergyCareful: number;
+        Expired: number;
+        Feather: number;
+        Folder: number;
+        FolderOpen: number;
+        FolderPackage: number;
+        Home: number;
+        Homebanking: number;
+        IRCommunication: number;
+        Identity: number;
+        Info: number;
+        Key: number;
+        List: number;
+        LockOpen: number;
+        MarkedDirectory: number;
+        Memory: number;
+        Money: number;
+        Monitor: number;
+        MultiKeys: number;
+        NetworkServer: number;
+        Note: number;
+        Notepad: number;
+        Package: number;
+        PaperFlag: number;
+        PaperLocked: number;
+        PaperNew: number;
+        PaperQ: number;
+        PaperReady: number;
+        Parts: number;
+        Pen: number;
+        Printer: number;
+        ProgramIcons: number;
+        Run: number;
+        Scanner: number;
+        Screen: number;
+        Settings: number;
+        Star: number;
+        TerminalEncrypted: number;
+        Thumbnail: number;
+        Tool: number;
+        TrashBin: number;
+        Tux: number;
+        UserCommunication: number;
+        UserKey: number;
+        Warning: number;
+        Wiki: number;
+        World: number;
+        WorldComputer: number;
+        WorldSocket: number;
+        WorldStar: number;
+    };
+    KdfId: {
+        Aes: string;
+        Argon2: string;
+    };
+    Signatures: {
+        FileMagic: number;
+        Sig2Kdb: number;
+        Sig2Kdbx: number;
+    };
+};
+
+export namespace ByteUtils {
+    function arrayBufferEquals(ab1: ArrayBuffer, ab2: ArrayBuffer): boolean;
+
+    function arrayToBuffer(arr: Uint8Array | ArrayBuffer): ArrayBuffer;
+
+    function base64ToBytes(str: string): Uint8Array;
+
+    function bytesToBase64(arr: Uint8Array | ArrayBuffer): string;
+
+    function bytesToHex(arr: Uint8Array | ArrayBuffer): string;
+
+    function bytesToString(arr: Uint8Array | ArrayBuffer): string;
+
+    function hexToBytes(hex: string): Uint8Array;
+
+    function stringToBytes(str: string): Uint8Array;
+
+    function zeroBuffer(buffer: Uint8Array | ArrayBuffer): void;
+}
+
+export namespace CryptoEngine {
+    const subtle: any;
+
+    const webCrypto: any;
+
+    function argon2(
+        password: ArrayBuffer,
+        salt: ArrayBuffer,
+        memory: number,
+        iterations: number,
+        length: number,
+        parallelism: number,
+        type: number,
+        version: number
+    ): Promise<ArrayBuffer>;
+
+    function chacha20(
+        data: ArrayBuffer,
+        key: ArrayBuffer,
+        iv: ArrayBuffer
+    ): Promise<ArrayBuffer>;
+
+    function configure(
+        newSubtle: SubtleCrypto | null,
+        newWebCrypto: Crypto | null,
+        newNodeCrypto: Crypto | null
+    ): void;
+
+    function createAesCbc(): any;
+
+    function hmacSha256(
+        key: ArrayBuffer,
+        data: ArrayBuffer
+    ): Promise<ArrayBuffer>;
+
+    function random(len: number): Uint8Array;
+
+    function sha256(data: ArrayBuffer): Promise<ArrayBuffer>;
+
+    function sha512(data: ArrayBuffer): Promise<ArrayBuffer>;
+}
+
+export namespace Random {
+    function getBytes(len: number): Uint8Array;
+}
+
+export class BinaryStream {
+    constructor(arrayBuffer: ArrayBuffer);
+
+    getByteLength(): number;
+
+    getFloat32(littleEdian?: boolean): number;
+
+    getFloat64(littleEdian?: boolean): number;
+
+    getInt16(littleEdian?: boolean): number;
+
+    getInt32(littleEdian?: boolean): number;
+
+    getInt8(littleEdian?: boolean): number;
+
+    getPos(): number;
+
+    getUint16(littleEdian?: boolean): number;
+
+    getUint32(littleEdian?: boolean): number;
+
+    getUint64(littleEdian?: boolean): number;
+
+    getUint8(littleEdian?: boolean): number;
+
+    getWrittenBytes(): ArrayBuffer;
+
+    readBytes(size: number): ArrayBuffer;
+
+    readBytesNoAdvance(startPos: number, endPos: number): ArrayBuffer;
+
+    readBytesToEnd(): ArrayBuffer;
+
+    setFloat32(value: number, littleEdian?: boolean): void;
+
+    setFloat64(value: number, littleEdian?: boolean): void;
+
+    setInt16(value: number, littleEdian?: boolean): void;
+
+    setInt32(value: number, littleEdian?: boolean): void;
+
+    setInt8(value: number, littleEdian?: boolean): void;
+
+    setUint16(value: number, littleEdian?: boolean): void;
+
+    setUint32(value: number, littleEdian?: boolean): void;
+
+    setUint64(value: number, littleEdian?: boolean): void;
+
+    setUint8(value: number, littleEdian?: boolean): void;
+
+    writeBytes(bytes: ArrayBuffer | Uint8Array): void;
+}
+
+export class Context {
+    constructor(opts: Kdbx);
+
+    setXmlDate(node: Node, dt: Date): void;
+}
+
+export class Group {
+    constructor();
+
+    static create(name: string, parentGroup: Group): Group;
+    static read(xmlNode: Node, ctx: Context, parentGroup: Group): Group;
+
+    write(parentNode: Node, ctx: Context): void;
+    forEach(
+        callback: (
+            thisArg: (value: any) => void,
+            entry: Entry | undefined
+        ) => void,
+        thisArg: (value: any) => void
+    ): void;
+    merge(objectMap: ObjectMap): void;
+    copyFrom(group: Group): void;
+}
+
+export class Entry {
+    constructor();
+
+    static create(meta: Meta, parentGroup: Group): Entry;
+    static read(xmlNode: Node, ctx: Context, parentGroup: Group): Entry;
+
+    write(parentNode: Node, ctx: Context): void;
+    pushHistory(): void;
+    removeHistory(index: number, count: number): void;
+    copyFrom(entry: Entry): void;
+    merge(objectMap: ObjectMap): void;
+}
+
+export class Meta {
+    constructor();
+
+    static create(): Meta;
+    static read(xmlNode: Node, ctx: Context): Meta;
+
+    write(parentNode: Node, ctx: Context): void;
+    merge(remote: Meta, objectMap: ObjectMap): void;
+}
diff --git a/types/kdbxweb/kdbxweb-tests.ts b/types/kdbxweb/kdbxweb-tests.ts
new file mode 100644
index 0000000000..d667117b6b
--- /dev/null
+++ b/types/kdbxweb/kdbxweb-tests.ts
@@ -0,0 +1,18 @@
+import * as kdbxweb from "kdbxweb";
+
+const dataarr = new ArrayBuffer(0);
+
+const credentials = new kdbxweb.Credentials(
+    kdbxweb.ProtectedValue.fromString("demo"),
+    "nFWx&e5SzT"
+);
+
+kdbxweb.Kdbx.load(dataarr, credentials).then(db => db);
+kdbxweb.Kdbx.loadXml("data", credentials).then(db =>  db);
+
+const newDb = kdbxweb.Kdbx.create(credentials, 'My new db');
+const group = newDb.createGroup(newDb.getDefaultGroup(), 'subgroup');
+const entry = newDb.createEntry(group);
+
+newDb.save().then(dataAsArrayBuffer => dataAsArrayBuffer);
+newDb.saveXml().then(xmlAsString => xmlAsString);
diff --git a/types/kdbxweb/tsconfig.json b/types/kdbxweb/tsconfig.json
new file mode 100644
index 0000000000..6c6083b077
--- /dev/null
+++ b/types/kdbxweb/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "kdbxweb-tests.ts"
+    ]
+}
diff --git a/types/kdbxweb/tslint.json b/types/kdbxweb/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/kdbxweb/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }