Merge pull request #17102 from dolanmiu/nodegit

High Quality Nodegit Typings

types/nodegit/annotated-commit.d.ts

@@ -0,0 +1,38 @@
+import { Repository } from './repository';
+import { Oid } from './oid';
+import { Reference } from './reference';
+
+export class AnnotatedCommit {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo - repository that contains the given commit
+     * @param {string} branchName - name of the (remote) branch
+     * @param {string} remoteUrl - 	url of the remote
+     * @param {Oid} id - the commit object id of the remote branch
+     * @returns {Promise<AnnotatedCommit>}
+     *
+     * @memberof AnnotatedCommit
+     */
+    static fromFetchhead(repo: Repository, branchName: string, remoteUrl: string, id: Oid): Promise<AnnotatedCommit>;
+    static fromRef(repo: Repository, ref: Reference): Promise<AnnotatedCommit>;
+    static fromRevspec(repo: Repository, revspec: string): Promise<AnnotatedCommit>;
+    static lookup(repo: Repository, id: Oid): Promise<AnnotatedCommit>;
+
+    /**
+     *
+     *
+     *
+     * @memberof AnnotatedCommit
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof AnnotatedCommit
+     */
+    id(): Oid;
+}

types/nodegit/attr.d.ts

@@ -0,0 +1,73 @@
+import { Repository } from './repository';
+
+export namespace Attr {
+    const enum STATES {
+        UNSPECIFIED_T = 0,
+        TRUE_T = 1,
+        FALSE_T = 2,
+        VALUE_T = 3
+    }
+}
+
+export class Attr {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @param {string} values
+     * @returns {number}
+     *
+     * @memberof Attr
+     */
+    static addMacro(repo: Repository, name: string, values: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     *
+     * @memberof Attr
+     */
+    static cacheFlush(repo: Repository): void;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo - The repository containing the path.
+     * @param {number} flags - A combination of GIT_ATTR_CHECK... flags.
+     * @param {string} path - The path to check for attributes. Relative paths are interpreted relative to the repo root.
+     * The file does not have to exist, but if it does not, then it will be treated as a plain file (not a directory).
+     * @param {string} name - The name of the attribute to look up.
+     * @returns {Promise<string>} - Output of the value of the attribute. Use the GIT_ATTR_...
+     *
+     * @memberof Attr
+     */
+    static get(repo: Repository, flags: number, path: string, name: string): Promise<string>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo - The repository containing the path.
+     * @param {number} flags - A combination of GIT_ATTR_CHECK... flags.
+     * @param {string} path - The path to check for attributes. Relative paths are interpreted relative to the repo root.
+     * The file does not have to exist, but if it does not, then it will be treated as a plain file (not a directory).
+     * @param {number} numAttr - The number of attributes being looked up
+     * @param {string} names - An array of num_attr strings containing attribute names.
+     * @returns {any[]}
+     *
+     * @memberof Attr
+     */
+    static getMany(repo: Repository, flags: number, path: string, numAttr: number, names: string): any[];
+    /**
+     *
+     *
+     * @static
+     * @param {string} attr - The attribute
+     * @returns {number}- the value type for the attribute
+     *
+     * @memberof Attr
+     */
+    static value(attr: string): number;
+}

types/nodegit/blame-hunk.d.ts

@@ -0,0 +1,61 @@
+import { Oid } from './oid';
+import { Signature } from './signature';
+
+export class BlameHunk {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof BlameHunk
+     */
+    linesInHunk: number;
+    /**
+     *
+     *
+     * @type {Oid}
+     * @memberof BlameHunk
+     */
+    finalCommitId: Oid;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof BlameHunk
+     */
+    finalStartLineNumber: number;
+    /**
+     *
+     *
+     * @type {Signature}
+     * @memberof BlameHunk
+     */
+    finalSignature: Signature;
+    /**
+     *
+     *
+     * @type {Oid}
+     * @memberof BlameHunk
+     */
+    origCommitId: Oid;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof BlameHunk
+     */
+    origPath: string;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof BlameHunk
+     */
+    origStartLineNumber: number;
+    /**
+     *
+     *
+     * @type {Signature}
+     * @memberof BlameHunk
+     */
+    origSignature: Signature;
+}

types/nodegit/blame-options.d.ts

@@ -0,0 +1,53 @@
+import {Oid} from './oid';
+
+export class BlameOptions {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof BlameOptions
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof BlameOptions
+     */
+    flags?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof BlameOptions
+     */
+    minMatchCharacters?: number;
+    /**
+     *
+     *
+     * @type {Oid}
+     * @memberof BlameOptions
+     */
+    newestCommit?: Oid;
+    /**
+     *
+     *
+     * @type {Oid}
+     * @memberof BlameOptions
+     */
+    oldestCommit?: Oid;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof BlameOptions
+     */
+    minLine?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof BlameOptions
+     */
+    maxLine?: number;
+}

types/nodegit/blame.d.ts

@@ -0,0 +1,84 @@
+import { Repository } from './repository';
+import { BlameOptions } from './blame-options';
+import {BlameHunk} from './blame-hunk';
+
+export namespace Blame {
+    const enum FLAG {
+        NORMAL = 0,
+        TRACK_COPIES_SAME_FILE = 1,
+        TRACK_COPIES_SAME_COMMIT_MOVES = 2,
+        TRACK_COPIES_SAME_COMMIT_COPIES = 4,
+        TRACK_COPIES_ANY_COMMIT_COPIES = 8,
+        FIRST_PARENT = 16
+    }
+}
+
+export class Blame {
+    /**
+     * Retrieve the blame of a file
+     *
+     * @static
+     * @param {Repository} repo - Repository that contains the file
+     * @param {string} path - to the file to get the blame of
+     * @param {BlameOptions} [options] - Options for the blame
+     * @returns {Blame}
+     *
+     * @memberof Blame
+     */
+    static file(repo: Repository, path: string, options?: BlameOptions): Blame;
+    /**
+     *
+     *
+     * @static
+     * @param {BlameOptions} opts - The git_blame_options struct to initialize
+     * @param {number} version - Version of struct; pass GIT_BLAME_OPTIONS_VERSION
+     * @returns {number}
+     *
+     * @memberof Blame
+     */
+    static initOptions(opts: BlameOptions, version: number): number;
+
+    /**
+     *
+     *
+     * @param {string} buffer
+     * @param {number} bufferLen
+     * @returns {Promise<Blame>}
+     *
+     * @memberof Blame
+     */
+    buffer(buffer: string, bufferLen: number): Promise<Blame>;
+    /**
+     *
+     *
+     *
+     * @memberof Blame
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @param {number} index
+     * @returns {BlameHunk} - the hunk at the given index, or NULL on error
+     *
+     * @memberof Blame
+     */
+    getHunkByIndex(index: number): BlameHunk;
+    /**
+     *
+     *
+     * @param {number} lineNo
+     * @returns {BlameHunk} - 	the hunk that contains the given line, or NULL on error
+     *
+     * @memberof Blame
+     */
+    getHunkByLine(lineNo: number): BlameHunk;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Blame
+     */
+    getHunkCount(): number;
+}

types/nodegit/blob.d.ts

@@ -0,0 +1,157 @@
+import { WriteStream } from 'fs';
+
+import { Repository } from './repository';
+import { Oid } from './oid';
+
+export class Blob {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo - repository where to blob will be written
+     * @param {Buffer} buffer - data to be written into the blob
+     * @param {number} len - length of the data
+     * @returns {Oid} - return the id of the written blob
+     *
+     * @memberof Blob
+     */
+    static createFromBuffer(repo: Repository, buffer: Buffer, len: number): Oid;
+    /**
+     *
+     *
+     * @static
+     * @param {Oid} id - return the id of the written blob
+     * @param {Repository} repo - repository where the blob will be written. this repository can be bare or not
+     * @param {string} path - file from which the blob will be created
+     * @returns {number}
+     *
+     * @memberof Blob
+     */
+    static createFromDisk(id: Oid, repo: Repository, path: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} hintPath
+     * @returns {Promise<WriteStream>}
+     *
+     * @memberof Blob
+     */
+    static createFromStream(repo: Repository, hintPath: string): Promise<WriteStream>;
+    /**
+     *
+     *
+     * @static
+     * @param {Oid} id - return the id of the written blob
+     * @param {Repository} repo - repository where the blob will be written. this repository cannot be bare
+     * @param {string} relativePath - file from which the blob will be created, relative to the repository's working dir
+     * @returns {number} - 0 or an error code
+     *
+     * @memberof Blob
+     */
+    static createFromWorkdir(id: Oid, repo: Repository, relativePath: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {(string | Oid | Blob)} id
+     * @returns {Promise<Blob>}
+     *
+     * @memberof Blob
+     */
+    static lookup(repo: Repository, id: string | Oid | Blob): Promise<Blob>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Oid} id
+     * @param {number} len
+     * @returns {Promise<Blob>}
+     *
+     * @memberof Blob
+     */
+    static lookupPrefix(repo: Repository, id: Oid, len: number): Promise<Blob>;
+
+    /**
+     *
+     *
+     *
+     * @memberof Blob
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Blob
+     */
+    id(): Oid;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Blob
+     */
+    isBinary(): number;
+    /**
+     *
+     *
+     * @returns {Repository}
+     *
+     * @memberof Blob
+     */
+    owner(): Repository;
+    /**
+     *
+     *
+     * @returns {Buffer}
+     *
+     * @memberof Blob
+     */
+    rawcontent(): Buffer;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Blob
+     */
+    rawsize(): number;
+    /**
+     *
+     *
+     * @returns {Buffer}
+     *
+     * @memberof Blob
+     */
+    content(): Buffer;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Blob
+     */
+    toString(): string;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Blob
+     */
+    filemode(): number;
+    /**
+     *
+     *
+     * @returns {Promise<Blob>}
+     *
+     * @memberof Blob
+     */
+    dup(): Promise<Blob>;
+}

types/nodegit/branch.d.ts

@@ -0,0 +1,127 @@
+import { Repository } from './repository';
+import { Reference } from './reference';
+import { Commit } from './commit';
+import { AnnotatedCommit } from './annotated-commit';
+
+export namespace Branch {
+    const enum BRANCH {
+        LOCAL = 1,
+        REMOTE = 2,
+        ALL = 3
+    }
+}
+
+export class Branch {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} branchName
+     * @param {Commit} target
+     * @param {number} force
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Branch
+     */
+    static create(repo: Repository, branchName: string, target: Commit, force: number): Promise<Reference>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repository
+     * @param {string} branchName
+     * @param {AnnotatedCommit} commit
+     * @param {number} force
+     * @returns {Reference}
+     *
+     * @memberof Branch
+     */
+    static createFromAnnotated(repository: Repository, branchName: string, commit: AnnotatedCommit, force: number): Reference;
+    /**
+     *
+     *
+     * @static
+     * @param {Reference} branch
+     * @returns {number}
+     *
+     * @memberof Branch
+     */
+    static delete(branch: Reference): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Reference} branch
+     * @returns {number}
+     *
+     * @memberof Branch
+     */
+    static isHead(branch: Reference): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {number} listFlags
+     * @returns {Promise<any>}
+     *
+     * @memberof Branch
+     */
+    static iteratorNew(repo: Repository, listFlags: number): Promise<any>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} branchName
+     * @param {Branch.BRANCH} branchType
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Branch
+     */
+    static lookup(repo: Repository, branchName: string, branchType: Branch.BRANCH): Promise<Reference>;
+    /**
+     *
+     *
+     * @static
+     * @param {Reference} branch
+     * @param {string} newBranchName
+     * @param {number} force
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Branch
+     */
+    static move(branch: Reference, newBranchName: string, force: number): Promise<Reference>;
+    /**
+     *
+     *
+     * @static
+     * @param {Reference} ref
+     * @returns {Promise<string>}
+     *
+     * @memberof Branch
+     */
+    static name(ref: Reference): Promise<string>;
+    /**
+     *
+     *
+     * @static
+     * @param {Reference} branch
+     * @param {string} upstreamName
+     * @returns {Promise<number>}
+     *
+     * @memberof Branch
+     */
+    static setUpstream(branch: Reference, upstreamName: string): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {Reference} branch
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Branch
+     */
+    static upstream(branch: Reference): Promise<Reference>;
+}

types/nodegit/buf.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="node" />
+
+export class Buf {
+        /**
+         *
+         *
+         * @returns {number}
+         *
+         * @memberof Buf
+         */
+        containsNul(): number;
+        /**
+         *
+         *
+         *
+         * @memberof Buf
+         */
+        free(): void;
+        /**
+         *
+         *
+         * @param {number} targetSize
+         * @returns {Promise<Buf>}
+         *
+         * @memberof Buf
+         */
+        grow(targetSize: number): Promise<Buf>;
+        /**
+         *
+         *
+         * @returns {number}
+         *
+         * @memberof Buf
+         */
+        isBinary(): number;
+        /**
+         *
+         *
+         * @param {Buffer} data
+         * @param {number} datalen
+         * @returns {Promise<Buf>}
+         *
+         * @memberof Buf
+         */
+        set(data: Buffer, datalen: number): Promise<Buf>;
+        /**
+         *
+         *
+         * @type {string}
+         * @memberof Buf
+         */
+        ptr: string;
+        /**
+         *
+         *
+         * @type {number}
+         * @memberof Buf
+         */
+        asize: number;
+        /**
+         *
+         *
+         * @type {number}
+         * @memberof Buf
+         */
+        size: number;
+    }

types/nodegit/cert-host-key.d.ts

@@ -0,0 +1,26 @@
+import { Cert } from './cert';
+
+export class CertHostkey {
+    /**
+     *
+     *
+     * @type {Cert}
+     * @memberof CertHostkey
+     */
+    parent: Cert;
+    type: Cert.TYPE;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof CertHostkey
+     */
+    hashMd5: string;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof CertHostkey
+     */
+    hashSha1: string;
+}

types/nodegit/cert-x509.d.ts

@@ -0,0 +1,25 @@
+import { Cert } from './cert';
+
+export class CertX509 {
+    /**
+     *
+     *
+     * @type {Buffer}
+     * @memberof CertX509
+     */
+    data: Buffer;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof CertX509
+     */
+    len: number;
+    /**
+     *
+     *
+     * @type {Cert}
+     * @memberof CertX509
+     */
+    parent: Cert;
+}

types/nodegit/cert.d.ts

@@ -0,0 +1,23 @@
+export namespace Cert {
+    const enum TYPE {
+        NONE = 0,
+        X509 = 1,
+        HOSTKEY_LIBSSH2 = 2,
+        STRARRAY = 3
+    }
+
+    const enum SSH {
+        MD5 = 1,
+        SHA1 = 2
+    }
+}
+
+export class Cert {
+    /**
+     *
+     *
+     * @type {Cert.TYPE}
+     * @memberof Cert
+     */
+    certType: Cert.TYPE;
+}

types/nodegit/checkout-options.d.ts

@@ -0,0 +1,146 @@
+import { Strarray } from './str-array';
+import { Tree } from './tree';
+import { Index } from './index';
+
+export class CheckoutOptions {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof CheckoutOptions
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof CheckoutOptions
+     */
+    checkoutStrategy?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof CheckoutOptions
+     */
+    disableFilters?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof CheckoutOptions
+     */
+    dirMode?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof CheckoutOptions
+     */
+    fileMode?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof CheckoutOptions
+     */
+    fileOpenFlags?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof CheckoutOptions
+     */
+    notifyFlags?: number;
+    /**
+     *
+     *
+     * @type {*}
+     * @memberof CheckoutOptions
+     */
+    notifyCb?: any;
+    /**
+     *
+     *
+     * @type {undefined}
+     * @memberof CheckoutOptions
+     */
+    notifyPayload?: undefined;
+    /**
+     *
+     *
+     * @type {*}
+     * @memberof CheckoutOptions
+     */
+    progressCb?: any;
+    /**
+     *
+     *
+     * @type {undefined}
+     * @memberof CheckoutOptions
+     */
+    progressPayload?: undefined;
+    /**
+     *
+     *
+     * @type {Strarray}
+     * @memberof CheckoutOptions
+     */
+    paths?: Strarray;
+    /**
+     *
+     *
+     * @type {Tree}
+     * @memberof CheckoutOptions
+     */
+    baseline?: Tree;
+    /**
+     *
+     *
+     * @type {Index}
+     * @memberof CheckoutOptions
+     */
+    baselineIndex?: Index;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof CheckoutOptions
+     */
+    targetDirectory?: string;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof CheckoutOptions
+     */
+    ancestorLabel?: string;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof CheckoutOptions
+     */
+    ourLabel?: string;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof CheckoutOptions
+     */
+    theirLabel?: string;
+    /**
+     *
+     *
+     * @type {*}
+     * @memberof CheckoutOptions
+     */
+    perfdataCb?: any;
+    /**
+     *
+     *
+     * @type {undefined}
+     * @memberof CheckoutOptions
+     */
+    perfdataPayload?: undefined;
+}

types/nodegit/checkout.d.ts

@@ -0,0 +1,93 @@
+import { Repository } from './repository';
+import { CheckoutOptions } from './checkout-options';
+import { Reference } from './reference';
+import { Oid } from './oid';
+import { Tree } from './tree';
+import { Commit } from './commit';
+import { Index } from './index';
+
+export namespace Checkout {
+    const enum NOTIFY {
+        NONE = 0,
+        CONFLICT = 1,
+        DIRTY = 2,
+        UPDATED = 4,
+        UNTRACKED = 8,
+        IGNORED = 16,
+        ALL = 65535
+    }
+
+    const enum STRATEGY {
+        NONE = 0,
+        SAFE = 1,
+        FORCE = 2,
+        RECREATE_MISSING = 4,
+        ALLOW_CONFLICTS = 16,
+        REMOVE_UNTRACKED = 32,
+        REMOVE_IGNORED = 64,
+        UPDATE_ONLY = 128,
+        DONT_UPDATE_INDEX = 256,
+        NO_REFRESH = 512,
+        SKIP_UNMERGED = 1024,
+        USE_OURS = 2048,
+        USE_THEIRS = 4096,
+        DISABLE_PATHSPEC_MATCH = 8192,
+        SKIP_LOCKED_DIRECTORIES = 262144,
+        DONT_OVERWRITE_IGNORED = 524288,
+        CONFLICT_STYLE_MERGE = 1048576,
+        CONFLICT_STYLE_DIFF3 = 2097152,
+        DONT_REMOVE_EXISTING = 4194304,
+        DONT_WRITE_INDEX = 8388608,
+        UPDATE_SUBMODULES = 65536,
+        UPDATE_SUBMODULES_IF_CHANGED = 131072
+    }
+}
+
+export class Checkout {
+    /**
+     * Patch head checkout to automatically coerce objects.
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {CheckoutOptions} [options]
+     * @returns {Promise<void>}
+     *
+     * @memberof Checkout
+     */
+    static head(repo: Repository, options?: CheckoutOptions): Promise<void>;
+    /**
+     * Patch index checkout to automatically coerce objects.
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Index} The
+     * @param {CheckoutOptions} [options]
+     * @returns {Promise<void>}
+     *
+     * @memberof Checkout
+     */
+    static index(repo: Repository, The: Index, options?: CheckoutOptions): Promise<void>;
+    /**
+     *
+     *
+     * @static
+     * @param {CheckoutOptions} opts
+     * @param {number} version
+     * @returns {number}
+     *
+     * @memberof Checkout
+     */
+    static initOptions(opts: CheckoutOptions, version: number): number;
+    /**
+     * Patch tree checkout to automatically coerce objects.
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {(Oid | Tree | Commit | Reference)} treeish
+     * @param {CheckoutOptions} [options]
+     * @returns {Promise<void>}
+     *
+     * @memberof Checkout
+     */
+    static tree(repo: Repository, treeish: Oid | Tree | Commit | Reference, options?: CheckoutOptions): Promise<void>;
+}

types/nodegit/cherry-pick-options.d.ts

@@ -0,0 +1,33 @@
+import { MergeOptions } from './merge-options';
+import { CheckoutOptions } from './checkout-options';
+
+export interface CherrypickOptions {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof CherrypickOptions
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof CherrypickOptions
+     */
+    mainline?: number;
+    /**
+     *
+     *
+     * @type {MergeOptions}
+     * @memberof CherrypickOptions
+     */
+    mergeOpts?: MergeOptions;
+    /**
+     *
+     *
+     * @type {CheckoutOptions}
+     * @memberof CherrypickOptions
+     */
+    checkoutOpts?: CheckoutOptions;
+}

types/nodegit/cherry-pick.d.ts

@@ -0,0 +1,44 @@
+import { Repository } from './repository';
+import { Commit } from './commit';
+import { MergeOptions } from './merge-options';
+import { CherrypickOptions } from './cherry-pick-options';
+
+export class Cherrypick {
+    /**
+     * Cherrypick a commit and, changing the index and working directory
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Commit} commit
+     * @param {CherrypickOptions} [options]
+     * @returns {Promise<number>}
+     *
+     * @memberof Cherrypick
+     */
+    static cherrypick(repo: Repository, commit: Commit, options?: CherrypickOptions): Promise<number>;
+    /**
+     * Cherrypicks the given commit against "our" commit, producing an index that reflects the result of the cherrypick. The index is not backed by a repo.
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Commit} cherrypickCommit
+     * @param {Commit} ourCommit
+     * @param {number} mainline
+     * @param {MergeOptions} [mergeOptions]
+     * @returns {Promise<number>}
+     *
+     * @memberof Cherrypick
+     */
+    static commit(repo: Repository, cherrypickCommit: Commit, ourCommit: Commit, mainline: number, mergeOptions?: MergeOptions): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {CherrypickOptions} opts
+     * @param {number} version
+     * @returns {number}
+     *
+     * @memberof Cherrypick
+     */
+    static initOptions(opts: CherrypickOptions, version: number): number;
+}

types/nodegit/clone-options.d.ts

@@ -0,0 +1,61 @@
+import { CheckoutOptions } from './checkout-options';
+import { FetchOptions } from './fetch-options';
+
+export class CloneOptions {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof CloneOptions
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {CheckoutOptions}
+     * @memberof CloneOptions
+     */
+    checkoutOpts?: CheckoutOptions;
+    /**
+     *
+     *
+     * @type {FetchOptions}
+     * @memberof CloneOptions
+     */
+    fetchOpts?: FetchOptions;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof CloneOptions
+     */
+    bare?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof CloneOptions
+     */
+    local?: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof CloneOptions
+     */
+    checkoutBranch?: string;
+    /**
+     *
+     *
+     * @type {*}
+     * @memberof CloneOptions
+     */
+    repositoryCbPayload?: any;
+    /**
+     *
+     *
+     * @type {*}
+     * @memberof CloneOptions
+     */
+    remoteCbPayload?: any;
+}

types/nodegit/clone.d.ts

@@ -0,0 +1,37 @@
+import { Repository } from './repository';
+import { CloneOptions } from './clone-options';
+
+export namespace Clone {
+    const enum LOCAL {
+        AUTO = 0,
+        LOCAL = 1,
+        NO_LOCAL = 2,
+        NO_LINKS = 3
+    }
+}
+
+export class Clone {
+    /**
+     * Patch repository cloning to automatically coerce objects.
+     *
+     * @static
+     * @param {string} url
+     * @param {string} localPath
+     * @param {CloneOptions} [options]
+     * @returns {Promise<Repository>}
+     *
+     * @memberof Clone
+     */
+    static clone(url: string, localPath: string, options?: CloneOptions): Promise<Repository>;
+    /**
+     *
+     *
+     * @static
+     * @param {CloneOptions} opts
+     * @param {number} version
+     * @returns {number}
+     *
+     * @memberof Clone
+     */
+    static initOptions(opts: CloneOptions, version: number): number;
+}

types/nodegit/commit.d.ts

@@ -0,0 +1,369 @@
+import { EventEmitter } from 'events';
+
+import { Repository } from './repository';
+import { Signature } from './signature';
+import { Oid } from './oid';
+import { Buf } from './buf';
+import { Object } from './object';
+import { Tree } from './tree';
+import { TreeEntry } from './tree-entry';
+import { Diff } from './diff';
+
+export class Commit {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} updateRef
+     * @param {Signature} author
+     * @param {Signature} committer
+     * @param {string} messageEncoding
+     * @param {string} message
+     * @param {Tree} tree
+     * @param {number} parentCount
+     * @param {any[]} parents
+     * @returns {Oid}
+     *
+     * @memberof Commit
+     */
+    static create(repo: Repository, updateRef: string, author: Signature, committer: Signature, messageEncoding: string, message: string, tree: Tree, parentCount: number, parents: any[]): Oid;
+    /**
+     *
+     *
+     * @static
+     * @param {Oid} id
+     * @param {Repository} repo
+     * @param {string} updateRef
+     * @param {Signature} author
+     * @param {Signature} committer
+     * @param {string} messageEncoding
+     * @param {string} message
+     * @param {Tree} tree
+     * @param {number} parentCount
+     * @returns {number}
+     *
+     * @memberof Commit
+     */
+    static createV(id: Oid, repo: Repository, updateRef: string, author: Signature, committer: Signature, messageEncoding: string, message: string, tree: Tree, parentCount: number): number;
+    /**
+     * Retrieves the commit pointed to by the oid
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {(string | Oid | Commit)} id
+     * @returns {Promise<Commit>}
+     *
+     * @memberof Commit
+     */
+    static lookup(repo: Repository, id: string | Oid | Commit): Promise<Commit>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Oid} id
+     * @param {number} len
+     * @returns {Promise<Commit>}
+     *
+     * @memberof Commit
+     */
+    static lookupPrefix(repo: Repository, id: Oid, len: number): Promise<Commit>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} commitContent
+     * @param {string} signature
+     * @param {string} signatureField
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Commit
+     */
+    static createWithSignature(repo: Repository, commitContent: string, signature: string, signatureField: string): Promise<Oid>;
+
+    /**
+     *
+     *
+     * @param {string} updateRef
+     * @param {Signature} author
+     * @param {Signature} committer
+     * @param {string} messageEncoding
+     * @param {string} message
+     * @param {Tree} tree
+     * @returns {Oid}
+     *
+     * @memberof Commit
+     */
+    amend(updateRef: string, author: Signature, committer: Signature, messageEncoding: string, message: string, tree: Tree): Oid;
+    /**
+     *
+     *
+     * @returns {Signature}
+     *
+     * @memberof Commit
+     */
+    author(): Signature;
+    /**
+     *
+     *
+     * @returns {Signature}
+     *
+     * @memberof Commit
+     */
+    committer(): Signature;
+    /**
+     *
+     *
+     *
+     * @memberof Commit
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @param {string} field
+     * @returns {Promise<Buf>}
+     *
+     * @memberof Commit
+     */
+    headerField(field: string): Promise<Buf>;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Commit
+     */
+    id(): Oid;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Commit
+     */
+    message(): string;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Commit
+     */
+    messageEncoding(): string;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Commit
+     */
+    messageRaw(): string;
+    /**
+     *
+     *
+     * @param {number} n
+     * @returns {Promise<Commit>}
+     *
+     * @memberof Commit
+     */
+    nthGenAncestor(n: number): Promise<Commit>;
+    /**
+     *
+     *
+     * @returns {Repository}
+     *
+     * @memberof Commit
+     */
+    owner(): Repository;
+    /**
+     *
+     *
+     * @param {number} n
+     * @returns {Promise<Commit>}
+     *
+     * @memberof Commit
+     */
+    parent(n: number): Promise<Commit>;
+    /**
+     *
+     *
+     * @param {number} n
+     * @returns {Oid}
+     *
+     * @memberof Commit
+     */
+    parentId(n: number): Oid;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Commit
+     */
+    parentcount(): number;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Commit
+     */
+    rawHeader(): string;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Commit
+     */
+    summary(): string;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Commit
+     */
+    time(): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Commit
+     */
+    timeOffset(): number;
+    /**
+     *
+     *
+     * @param {Tree} treeOut
+     * @returns {number}
+     *
+     * @memberof Commit
+     */
+    tree(treeOut: Tree): number;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Commit
+     */
+    treeId(): Oid;
+    /**
+     * Retrieve the SHA.
+     *
+     * @returns {string}
+     *
+     * @memberof Commit
+     */
+    sha(): string;
+    /**
+     * Retrieve the commit time as a unix timestamp.
+     *
+     * @returns {number}
+     *
+     * @memberof Commit
+     */
+    timeMs(): number;
+    /**
+     * Retrieve the commit time as a Date object.
+     *
+     * @returns {Date}
+     *
+     * @memberof Commit
+     */
+    date(): Date;
+    /**
+     * Get the tree associated with this commit.
+     *
+     * @returns {Promise<Tree>}
+     *
+     * @memberof Commit
+     */
+    getTree(): Promise<Tree>;
+    /**
+     * Retrieve the entry represented by path for this commit. Path must be relative to repository root.
+     *
+     * @param {string} path
+     * @returns {Promise<TreeEntry>}
+     *
+     * @memberof Commit
+     */
+    getEntry(path: string): Promise<TreeEntry>;
+    /**
+     * Walk the history from this commit backwards.
+     * An EventEmitter is returned that will emit a "commit" event for each commit in the history, and one "end"
+     * event when the walk is completed. Don't forget to call start() on the returned event.
+     *
+     * @returns {EventEmitter}
+     *
+     * @memberof Commit
+     */
+    history(): EventEmitter;
+    /**
+     * Retrieve the commit's parents as commit objects.
+     *
+     * @param {number} limit
+     * @param {Function} callback
+     * @returns {Promise<Commit[]>}
+     *
+     * @memberof Commit
+     */
+    getParents(limit: number, callback: Function): Promise<Commit[]>;
+    /**
+     * Retrieve the commit's parent shas.
+     *
+     * @param {Function} callback
+     * @returns {Oid[]}
+     *
+     * @memberof Commit
+     */
+    parents(callback: Function): Oid[];
+    /**
+     * Generate an array of diff trees showing changes between this commit and its parent(s).
+     *
+     * @param {Function} callback
+     * @returns {Promise<Diff[]>}
+     *
+     * @memberof Commit
+     */
+    getDiff(callback: Function): Promise<Diff[]>;
+    /**
+     * Generate an array of diff trees showing changes between this commit and its parent(s).
+     *
+     * @param {Object} options
+     * @param {Function} callback
+     * @returns {Promise<Diff[]>}
+     *
+     * @memberof Commit
+     */
+    getDiffWithOptions(options: Object, callback: Function): Promise<Diff[]>;
+    /**
+     * The sha of this commit
+     *
+     * @returns {string}
+     *
+     * @memberof Commit
+     */
+    toString(): string;
+    /**
+     *
+     *
+     * @returns {Promise<Commit>}
+     *
+     * @memberof Commit
+     */
+    dup(): Promise<Commit>;
+    /**
+     * consists of a summary
+     *
+     * @returns {string}
+     *
+     * @memberof Commit
+     */
+    body(): string;
+}

types/nodegit/config.d.ts

@@ -0,0 +1,91 @@
+import { Buf } from './buf';
+
+export namespace Config {
+    const enum LEVEL {
+        SYSTEM = 1,
+        XDG = 2,
+        GLOBAL = 3,
+        LOCAL = 4,
+        APP = 5,
+        HIGHEST_LEVEL = -1
+    }
+}
+
+export class Config {
+    /**
+     *
+     *
+     * @static
+     * @returns {Promise<Config>}
+     *
+     * @memberof Config
+     */
+    static openDefault(): Promise<Config>;
+    /**
+     *
+     *
+     * @static
+     * @returns {Promise<Buf>}
+     *
+     * @memberof Config
+     */
+    static findProgramdata(): Promise<Buf>;
+
+    /**
+     *
+     *
+     * @param {string} name
+     * @returns {Promise<Buf>}
+     *
+     * @memberof Config
+     */
+    getStringBuf(name: string): Promise<Buf>;
+    /**
+     *
+     *
+     * @param {string} name
+     * @param {number} value
+     * @returns {number}
+     *
+     * @memberof Config
+     */
+    setInt64(name: string, value: number): number;
+    /**
+     *
+     *
+     * @param {string} name
+     * @param {string} regexp
+     * @param {string} value
+     * @returns {number}
+     *
+     * @memberof Config
+     */
+    setMultivar(name: string, regexp: string, value: string): number;
+    /**
+     *
+     *
+     * @param {string} name
+     * @param {string} value
+     * @returns {Promise<number>}
+     *
+     * @memberof Config
+     */
+    setString(name: string, value: string): Promise<number>;
+    /**
+     *
+     *
+     * @returns {Promise<Config>}
+     *
+     * @memberof Config
+     */
+    snapshot(): Promise<Config>;
+    /**
+     *
+     *
+     * @param {*} transaction
+     * @returns {number}
+     *
+     * @memberof Config
+     */
+    lock(transaction: any): number;
+}

types/nodegit/convenient-patch.d.ts

@@ -0,0 +1,140 @@
+import { DiffFile } from './diff-file';
+
+export class ConvenientPatch {
+    /**
+     * Old attributes of the file
+     *
+     * @returns {DiffFile}
+     *
+     * @memberof ConvenientPatch
+     */
+    oldFile(): DiffFile;
+    /**
+     * New attributes of the file
+     *
+     * @returns {DiffFile}
+     *
+     * @memberof ConvenientPatch
+     */
+    newFile(): DiffFile;
+    /**
+     * The number of hunks in this patch
+     *
+     * @returns {number}
+     *
+     * @memberof ConvenientPatch
+     */
+    size(): number;
+    /**
+     * The hunks in this patch
+     *
+     * @returns {Promise<any[]>}
+     *
+     * @memberof ConvenientPatch
+     */
+    hunks(): Promise<any[]>;
+    /**
+     * The status of this patch (unmodified, added, deleted)
+     *
+     * @returns {number}
+     *
+     * @memberof ConvenientPatch
+     */
+    status(): number;
+    /**
+     * The line statistics of this patch (#contexts, #added, #deleted)
+     *
+     * @returns {*}
+     *
+     * @memberof ConvenientPatch
+     */
+    lineStats(): any;
+    /**
+     * Is this an unmodified patch?
+     *
+     * @returns {boolean}
+     *
+     * @memberof ConvenientPatch
+     */
+    isUnmodified(): boolean;
+    /**
+     * Is this an added patch?
+     *
+     * @returns {boolean}
+     *
+     * @memberof ConvenientPatch
+     */
+    isAdded(): boolean;
+    /**
+     * Is this a deleted patch?
+     *
+     * @returns {boolean}
+     *
+     * @memberof ConvenientPatch
+     */
+    isDeleted(): boolean;
+    /**
+     * Is this an modified patch?
+     *
+     * @returns {boolean}
+     *
+     * @memberof ConvenientPatch
+     */
+    isModified(): boolean;
+    /**
+     * Is this a renamed patch?
+     *
+     * @returns {boolean}
+     *
+     * @memberof ConvenientPatch
+     */
+    isRenamed(): boolean;
+    /**
+     * Is this a copied patch?
+     *
+     * @returns {boolean}
+     *
+     * @memberof ConvenientPatch
+     */
+    isCopied(): boolean;
+    /**
+     * Is this an ignored patch?
+     *
+     * @returns {boolean}
+     *
+     * @memberof ConvenientPatch
+     */
+    isIgnored(): boolean;
+    /**
+     * Is this an untracked patch?
+     *
+     * @returns {boolean}
+     *
+     * @memberof ConvenientPatch
+     */
+    isUntracked(): boolean;
+    /**
+     * Is this a type change?
+     *
+     * @returns {boolean}
+     *
+     * @memberof ConvenientPatch
+     */
+    isTypeChange(): boolean;
+    /**
+     * Is this an undreadable patch?
+     *
+     * @returns {boolean}
+     *
+     * @memberof ConvenientPatch
+     */
+    isUnreadable(): boolean;
+    /**
+     * Is this a conflicted patch?
+     *
+     * @returns {boolean}
+     *
+     * @memberof ConvenientPatch
+     */
+    isConflicted(): boolean;
+}

types/nodegit/cred-user-pass-payload.d.ts

@@ -0,0 +1,16 @@
+export class CredUserpassPayload {
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof CredUserpassPayload
+     */
+    username: string;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof CredUserpassPayload
+     */
+    password: string;
+}

types/nodegit/cred-username.d.ts

@@ -0,0 +1,18 @@
+import { Cred } from './cred';
+
+export class CredUsername {
+    /**
+     *
+     *
+     * @type {Cred}
+     * @memberof CredUsername
+     */
+    parent: Cred;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof CredUsername
+     */
+    username: string;
+}

types/nodegit/cred.d.ts

@@ -0,0 +1,96 @@
+export namespace Cred {
+    const enum TYPE {
+        USERPASS_PLAINTEXT = 1,
+        SSH_KEY = 2,
+        SSH_CUSTOM = 4,
+        DEFAULT = 8,
+        SSH_INTERACTIVE = 16,
+        USERNAME = 32,
+        SSH_MEMORY = 64
+    }
+}
+
+export class Cred {
+    /**
+     *
+     *
+     * @static
+     * @returns {Cred}
+     *
+     * @memberof Cred
+     */
+    static defaultNew(): Cred;
+    /**
+     *
+     *
+     * @static
+     * @param {string} username
+     * @returns {Cred}
+     *
+     * @memberof Cred
+     */
+    static sshKeyFromAgent(username: string): Cred;
+    /**
+     *
+     *
+     * @static
+     * @param {string} username
+     * @param {string} publicKey
+     * @param {string} privateKey
+     * @param {string} passphrase
+     * @returns {Promise<Cred>}
+     *
+     * @memberof Cred
+     */
+    static sshKeyMemoryNew(username: string, publicKey: string, privateKey: string, passphrase: string): Promise<Cred>;
+    /**
+     *
+     *
+     * @static
+     * @param {string} username
+     * @param {string} publicKey
+     * @param {string} privateKey
+     * @param {string} passphrase
+     * @returns {Cred}
+     *
+     * @memberof Cred
+     */
+    static sshKeyNew(username: string, publicKey: string, privateKey: string, passphrase: string): Cred;
+    /**
+     *
+     *
+     * @static
+     * @param {string} username
+     * @returns {Promise<Cred>}
+     *
+     * @memberof Cred
+     */
+    static usernameNew(username: string): Promise<Cred>;
+    /**
+     *
+     *
+     * @static
+     * @param {string} username
+     * @param {string} password
+     * @returns {Cred}
+     *
+     * @memberof Cred
+     */
+    static userpassPlaintextNew(username: string, password: string): Cred;
+
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Cred
+     */
+    hasUsername(): number;
+    /**
+     *
+     *
+     *
+     * @memberof Cred
+     */
+    free(): void;
+}

types/nodegit/cvar-map.d.ts

@@ -0,0 +1,23 @@
+export class CvarMap {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof CvarMap
+     */
+    cvarType: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof CvarMap
+     */
+    strMatch: string;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof CvarMap
+     */
+    mapValue: number;
+}

types/nodegit/describe-format-options.d.ts

@@ -0,0 +1,30 @@
+export class DescribeFormatOptions {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DescribeFormatOptions
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DescribeFormatOptions
+     */
+    abbreviatedSize?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DescribeFormatOptions
+     */
+    alwaysUseLongFormat?: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof DescribeFormatOptions
+     */
+    dirtySuffix?: string;
+}

types/nodegit/describe-options.d.ts

@@ -0,0 +1,44 @@
+export class DescribeOptions {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DescribeOptions
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DescribeOptions
+     */
+    maxCandidatesTags?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DescribeOptions
+     */
+    describeStrategy?: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof DescribeOptions
+     */
+    pattern?: string;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DescribeOptions
+     */
+    onlyFollowFirstParent?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DescribeOptions
+     */
+    showCommitOidAsFallback?: number;
+}

types/nodegit/diff-binary-file.d.ts

@@ -0,0 +1,30 @@
+export class DiffBinaryFile {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffBinaryFile
+     */
+    type: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof DiffBinaryFile
+     */
+    data: string;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffBinaryFile
+     */
+    datalen: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffBinaryFile
+     */
+    inflatedlen: number;
+}

types/nodegit/diff-binary.d.ts

@@ -0,0 +1,33 @@
+import { DiffBinaryFile } from './diff-binary-file';
+
+export namespace DiffBinary {
+    const enum DIFF_BINARY {
+        NONE = 0,
+        LITERAL = 1,
+        DELTA = 2
+    }
+}
+
+export class DiffBinary {
+    /**
+     *
+     *
+     * @type {DiffBinaryFile}
+     * @memberof DiffBinary
+     */
+    oldFile: DiffBinaryFile;
+    /**
+     *
+     *
+     * @type {DiffBinaryFile}
+     * @memberof DiffBinary
+     */
+    newFile: DiffBinaryFile;
+    /**
+     *
+     *
+     * @type {DiffBinary.DIFF_BINARY}
+     * @memberof DiffBinary
+     */
+    containsData: DiffBinary.DIFF_BINARY;
+}

types/nodegit/diff-delta.d.ts

@@ -0,0 +1,46 @@
+import { DiffFile } from './diff-file';
+
+export class DiffDelta {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffDelta
+     */
+    status: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffDelta
+     */
+    flags: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffDelta
+     */
+    similarity: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffDelta
+     */
+    nfiles: number;
+    /**
+     *
+     *
+     * @type {DiffFile}
+     * @memberof DiffDelta
+     */
+    oldFile: DiffFile;
+    /**
+     *
+     *
+     * @type {DiffFile}
+     * @memberof DiffDelta
+     */
+    newFile: DiffFile;
+}

types/nodegit/diff-file.d.ts

@@ -0,0 +1,44 @@
+import { Oid } from './oid';
+
+export class DiffFile {
+    /**
+     * Returns the file's flags
+     *
+     * @returns {number}
+     *
+     * @memberof DiffFile
+     */
+    flags(): number;
+    /**
+     * Returns the file's Oid
+     *
+     * @returns {Oid}
+     *
+     * @memberof DiffFile
+     */
+    id(): Oid;
+    /**
+     * Returns the file's mode
+     *
+     * @returns {number}
+     *
+     * @memberof DiffFile
+     */
+    mode(): number;
+    /**
+     * Returns the file's path
+     *
+     * @returns {string}
+     *
+     * @memberof DiffFile
+     */
+    path(): string;
+    /**
+     * Returns the file's size
+     *
+     * @returns {number}
+     *
+     * @memberof DiffFile
+     */
+    size(): number;
+}

types/nodegit/diff-hunk.d.ts

@@ -0,0 +1,44 @@
+export class DiffHunk {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffHunk
+     */
+    oldStart: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffHunk
+     */
+    oldLines: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffHunk
+     */
+    newStart: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffHunk
+     */
+    newLines: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffHunk
+     */
+    headerLen: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof DiffHunk
+     */
+    header: string;
+}

types/nodegit/diff-line.d.ts

@@ -0,0 +1,60 @@
+export class DiffLine {
+    /**
+     * The relevant line
+     *
+     * @returns {string}
+     *
+     * @memberof DiffLine
+     */
+    content(): string;
+    /**
+     * The non utf8 translated text
+     *
+     * @returns {string}
+     *
+     * @memberof DiffLine
+     */
+    rawContent(): string;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffLine
+     */
+    origin: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffLine
+     */
+    oldLineno: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffLine
+     */
+    newLineno: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffLine
+     */
+    numLines: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffLine
+     */
+    contentLen: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffLine
+     */
+    contentOffset: number;
+}

types/nodegit/diff-options.d.ts

@@ -0,0 +1,95 @@
+import { Strarray } from './str-array';
+
+export interface DiffOptions {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffOptions
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffOptions
+     */
+    flags?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffOptions
+     */
+    ignoreSubmodules?: number;
+    /**
+     *
+     *
+     * @type {Strarray}
+     * @memberof DiffOptions
+     */
+    pathspec?: Strarray;
+    /**
+     *
+     *
+     * @type {Function}
+     * @memberof DiffOptions
+     */
+    notifyCb?: Function;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffOptions
+     */
+    contextLines?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffOptions
+     */
+    interhunkLines?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffOptions
+     */
+    idAbbrev?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffOptions
+     */
+    maxSize?: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof DiffOptions
+     */
+    oldPrefix?: string;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof DiffOptions
+     */
+    newPrefix?: string;
+    /**
+     *
+     *
+     * @type {*}
+     * @memberof DiffOptions
+     */
+    payload?: any;
+    /**
+     *
+     *
+     * @type {*}
+     * @memberof DiffOptions
+     */
+    progressCb?: any;
+}

types/nodegit/diff-perf-data.d.ts

@@ -0,0 +1,23 @@
+export class DiffPerfdata {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffPerfdata
+     */
+    version: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffPerfdata
+     */
+    statCalls: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffPerfdata
+     */
+    oidCalculations: number;
+}

types/nodegit/diff.d.ts

@@ -0,0 +1,337 @@
+import { Blob } from './blob';
+import { Repository } from './repository';
+import { Tree } from './tree';
+import { Strarray } from './str-array';
+import { Index } from './index_';
+import { DiffDelta } from './diff-delta';
+import { DiffPerfdata } from './diff-perf-data';
+import { DiffOptions } from './diff-options';
+import { Buf } from './buf';
+
+export interface DiffFindOptions {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffFindOptions
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffFindOptions
+     */
+    flags?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffFindOptions
+     */
+    renameThreshold?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffFindOptions
+     */
+    renameFromRewriteThreshold?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffFindOptions
+     */
+    copyThreshold?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffFindOptions
+     */
+    breakRewriteThreshold?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof DiffFindOptions
+     */
+    renameLimit?: number;
+}
+
+export namespace Diff {
+    const enum DELTA {
+        UNMODIFIED = 0,
+        ADDED = 1,
+        DELETED = 2,
+        MODIFIED = 3,
+        RENAMED = 4,
+        COPIED = 5,
+        IGNORED = 6,
+        UNTRACKED = 7,
+        TYPECHANGE = 8,
+        UNREADABLE = 9,
+        CONFLICTED = 10
+    }
+
+    const enum FIND {
+        BY_CONFIG = 0,
+        RENAMES = 1,
+        RENAMES_FROM_REWRITES = 2,
+        COPIES = 4,
+        COPIES_FROM_UNMODIFIED = 8,
+        REWRITES = 16,
+        BREAK_REWRITES = 32,
+        AND_BREAK_REWRITES = 48,
+        FOR_UNTRACKED = 64,
+        ALL = 255,
+        IGNORE_LEADING_WHITESPACE = 0,
+        IGNORE_WHITESPACE = 4096,
+        DONT_IGNORE_WHITESPACE = 8192,
+        EXACT_MATCH_ONLY = 16384,
+        BREAK_REWRITES_FOR_RENAMES_ONLY = 32768,
+        REMOVE_UNMODIFIED = 65536
+    }
+
+    const enum FLAG {
+        BINARY = 1,
+        NOT_BINARY = 2,
+        VALID_ID = 4,
+        EXISTS = 8
+    }
+
+    const enum FORMAT {
+        PATCH = 1,
+        PATCH_HEADER = 2,
+        RAW = 3,
+        NAME_ONLY = 4,
+        NAME_STATUS = 5
+    }
+
+    const enum FORMAT_EMAIL_FLAGS {
+        FORMAT_EMAIL_NONE = 0,
+        FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER = 1
+    }
+
+    const enum LINE {
+        CONTEXT = 32,
+        ADDITION = 43,
+        DELETION = 45,
+        CONTEXT_EOFNL = 61,
+        ADD_EOFNL = 62,
+        DEL_EOFNL = 60,
+        FILE_HDR = 70,
+        HUNK_HDR = 72,
+        BINARY = 66
+    }
+
+    const enum OPTION {
+        NORMAL = 0,
+        REVERSE = 1,
+        INCLUDE_IGNORED = 2,
+        RECURSE_IGNORED_DIRS = 4,
+        INCLUDE_UNTRACKED = 8,
+        RECURSE_UNTRACKED_DIRS = 16,
+        INCLUDE_UNMODIFIED = 32,
+        INCLUDE_TYPECHANGE = 64,
+        INCLUDE_TYPECHANGE_TREES = 128,
+        IGNORE_FILEMODE = 256,
+        IGNORE_SUBMODULES = 512,
+        IGNORE_CASE = 1024,
+        INCLUDE_CASECHANGE = 2048,
+        DISABLE_PATHSPEC_MATCH = 4096,
+        SKIP_BINARY_CHECK = 8192,
+        ENABLE_FAST_UNTRACKED_DIRS = 16384,
+        UPDATE_INDEX = 32768,
+        INCLUDE_UNREADABLE = 65536,
+        INCLUDE_UNREADABLE_AS_UNTRACKED = 131072,
+        FORCE_TEXT = 1048576,
+        FORCE_BINARY = 2097152,
+        IGNORE_WHITESPACE = 4194304,
+        IGNORE_WHITESPACE_CHANGE = 8388608,
+        IGNORE_WHITESPACE_EOL = 16777216,
+        SHOW_UNTRACKED_CONTENT = 33554432,
+        SHOW_UNMODIFIED = 67108864,
+        PATIENCE = 268435456,
+        MINIMAL = 536870912,
+        SHOW_BINARY = 1073741824
+    }
+
+    const enum STATS_FORMAT {
+        STATS_NONE = 0,
+        STATS_FULL = 1,
+        STATS_SHORT = 2,
+        STATS_NUMBER = 4,
+        STATS_INCLUDE_SUMMARY = 8
+    }
+}
+
+export class Diff {
+    /**
+     * Directly run a diff between a blob and a buffer.
+     *
+     * @static
+     * @param {Blob} oldBlob
+     * @param {string} oldAsPath
+     * @param {string} buffer
+     * @param {string} bufferAsPath
+     * @param {DiffOptions} opts
+     * @param {Function} fileCb
+     * @param {Function} binaryCb
+     * @param {Function} hunkCb
+     * @param {Function} lineCb
+     * @returns {Promise<any>}
+     *
+     * @memberof Diff
+     */
+    static blobToBuffer(oldBlob: Blob, oldAsPath: string,
+                        buffer: string, bufferAsPath: string, opts: DiffOptions, fileCb: Function, binaryCb: Function, hunkCb: Function, lineCb: Function): Promise<any>;
+    /**
+     *
+     *
+     * @static
+     * @param {string} content
+     * @param {number} contentLen
+     * @returns {Promise<Diff>}
+     *
+     * @memberof Diff
+     */
+    static fromBuffer(content: string, contentLen: number): Promise<Diff>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Index} index
+     * @param {DiffOptions} opts
+     * @returns {Promise<Diff>}
+     *
+     * @memberof Diff
+     */
+    static indexToWorkdir(repo: Repository, index: Index, opts: DiffOptions): Promise<Diff>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Index} oldIndex
+     * @param {Index} newIndex
+     * @param {DiffOptions} opts
+     * @returns {Promise<Diff>}
+     *
+     * @memberof Diff
+     */
+    static indexToIndex(repo: Repository, oldIndex: Index, newIndex: Index, opts: DiffOptions): Promise<Diff>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Tree} oldTree
+     * @param {Index} index
+     * @param {DiffOptions} opts
+     * @returns {Promise<Diff>}
+     *
+     * @memberof Diff
+     */
+    static treeToIndex(repo: Repository, oldTree: Tree, index: Index, opts: DiffOptions): Promise<Diff>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Tree} oldTree
+     * @param {Tree} new_tree
+     * @param {DiffOptions} opts
+     * @returns {Promise<Diff>}
+     *
+     * @memberof Diff
+     */
+    static treeToTree(repo: Repository, oldTree: Tree, new_tree: Tree, opts: DiffOptions): Promise<Diff>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Tree} oldTree
+     * @param {DiffOptions} opts
+     * @returns {Promise<Diff>}
+     *
+     * @memberof Diff
+     */
+    static treeToWorkdir(repo: Repository, oldTree: Tree, opts: DiffOptions): Promise<Diff>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Tree} oldTree
+     * @param {DiffOptions} opts
+     * @returns {Promise<Diff>}
+     *
+     * @memberof Diff
+     */
+    static treeToWorkdirWithIndex(repo: Repository, oldTree: Tree, opts: DiffOptions): Promise<Diff>;
+
+    /**
+     *
+     *
+     * @param {DiffFindOptions} options
+     * @returns {Promise<number>}
+     *
+     * @memberof Diff
+     */
+    findSimilar(options: DiffFindOptions): Promise<number>;
+    /**
+     *
+     *
+     * @param {number} idx
+     * @returns {DiffDelta}
+     *
+     * @memberof Diff
+     */
+    getDelta(idx: number): DiffDelta;
+    /**
+     *
+     *
+     * @returns {Promise<DiffPerfdata>}
+     *
+     * @memberof Diff
+     */
+    getPerfdata(): Promise<DiffPerfdata>;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Diff
+     */
+    numDeltas(): number;
+    /**
+     * Retrieve patches in this difflist
+     *
+     * @returns {Promise<any[]>}
+     *
+     * @memberof Diff
+     */
+    patches(): Promise<any[]>;
+    /**
+     *
+     *
+     * @param {Diff} from
+     * @returns {Promise<number>}
+     *
+     * @memberof Diff
+     */
+    merge(from: Diff): Promise<number>;
+    /**
+     *
+     *
+     * @param {Diff.FORMAT} format
+     * @returns {Promise<Buf>}
+     *
+     * @memberof Diff
+     */
+    toBuf(format: Diff.FORMAT): Promise<Buf>;
+}

types/nodegit/enums.d.ts

@@ -0,0 +1,41 @@
+export namespace Enums {
+    const enum CVAR {
+        FALSE = 0,
+        TRUE = 1,
+        INT32 = 2,
+        string = 3
+    }
+
+    const enum DIRECTION {
+        FETCH = 0,
+        PUSH = 1
+    }
+
+    const enum FEATURE {
+        THREADS = 1,
+        HTTPS = 2,
+        SSH = 4
+    }
+
+    const enum IDXENTRY_EXTENDED_FLAG {
+        IDXENTRY_INTENT_TO_ADD = 8192,
+        IDXENTRY_SKIP_WORKTREE = 16384,
+        IDXENTRY_EXTENDED2 = 32768,
+        S = 24576,
+        IDXENTRY_UPDATE = 1,
+        IDXENTRY_REMOVE = 2,
+        IDXENTRY_UPTODATE = 4,
+        IDXENTRY_ADDED = 8,
+        IDXENTRY_HASHED = 16,
+        IDXENTRY_UNHASHED = 32,
+        IDXENTRY_WT_REMOVE = 64,
+        IDXENTRY_CONFLICTED = 128,
+        IDXENTRY_UNPACKED = 256,
+        IDXENTRY_NEW_SKIP_WORKTREE = 512
+    }
+
+    const enum INDXENTRY_FLAG {
+        IDXENTRY_EXTENDED = 16384,
+        IDXENTRY_VALID = 32768
+    }
+}

types/nodegit/error.d.ts

@@ -0,0 +1,80 @@
+export namespace Error {
+    const enum ERROR {
+        GITERR_NONE = 0,
+        GITERR_NOMEMORY = 1,
+        GITERR_OS = 2,
+        GITERR_INVALID = 3,
+        GITERR_REFERENCE = 4,
+        GITERR_ZLIB = 5,
+        GITERR_REPOSITORY = 6,
+        GITERR_CONFIG = 7,
+        GITERR_REGEX = 8,
+        GITERR_ODB = 9,
+        GITERR_INDEX = 10,
+        GITERR_OBJECT = 11,
+        GITERR_NET = 12,
+        GITERR_TAG = 13,
+        GITERR_TREE = 14,
+        GITERR_INDEXER = 15,
+        GITERR_SSL = 16,
+        GITERR_SUBMODULE = 17,
+        GITERR_THREAD = 18,
+        GITERR_STASH = 19,
+        GITERR_CHECKOUT = 20,
+        GITERR_FETCHHEAD = 21,
+        GITERR_MERGE = 22,
+        GITERR_SSH = 23,
+        GITERR_FILTER = 24,
+        GITERR_REVERT = 25,
+        GITERR_CALLBACK = 26,
+        GITERR_CHERRYPICK = 27,
+        GITERR_DESCRIBE = 28,
+        GITERR_REBASE = 29,
+        GITERR_FILESYSTEM = 30
+    }
+
+    const enum CODE {
+        OK = 0,
+        ERROR = -1,
+        ENOTFOUND = -3,
+        EEXISTS = -4,
+        EAMBIGUOUS = -5,
+        EBUFS = -6,
+        EUSER = -7,
+        EBAREREPO = -8,
+        EUNBORNBRANCH = -9,
+        EUNMERGED = -10,
+        ENONFASTFORWARD = -11,
+        EINVALIDSPEC = -12,
+        ECONFLICT = -13,
+        ELOCKED = -14,
+        EMODIFIED = -15,
+        EAUTH = -16,
+        ECERTIFICATE = -17,
+        EAPPLIED = -18,
+        EPEEL = -19,
+        EEOF = -20,
+        EINVALID = -21,
+        EUNCOMMITTED = -22,
+        EDIRECTORY = -23,
+        PASSTHROUGH = -30,
+        ITEROVER = -31
+    }
+}
+
+export class Error {
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof Error
+     */
+    message: string;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof Error
+     */
+    klass: number;
+}

types/nodegit/fetch-options.d.ts

@@ -0,0 +1,54 @@
+import { RemoteCallbacks } from './remote-callbacks';
+import { Strarray} from './str-array';
+
+export interface FetchOptions {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof FetchOptions
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {RemoteCallbacks}
+     * @memberof FetchOptions
+     */
+    callbacks?: RemoteCallbacks;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof FetchOptions
+     */
+    prune?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof FetchOptions
+     */
+    updateFetchhead?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof FetchOptions
+     */
+    downloadTags?: number;
+    /**
+     *
+     *
+     * @type {Strarray}
+     * @memberof FetchOptions
+     */
+    customHeaders?: Strarray;
+    /**
+     *
+     *
+     * @type {*}
+     * @memberof FetchOptions
+     */
+    proxyOpts?: any;
+}

types/nodegit/fetch.d.ts

@@ -0,0 +1,23 @@
+import { FetchOptions } from './fetch-options';
+
+export namespace Fetch {
+    const enum PRUNE {
+        GIT_FETCH_PRUNE_UNSPECIFIED = 0,
+        GIT_FETCH_PRUNE = 1,
+        GIT_FETCH_NO_PRUNE = 2
+    }
+}
+
+export class Fetch {
+    /**
+     *
+     *
+     * @static
+     * @param {FetchOptions} opts
+     * @param {number} version
+     * @returns {number}
+     *
+     * @memberof Fetch
+     */
+    static initOptions(opts: FetchOptions, version: number): number;
+}

types/nodegit/filter.d.ts

@@ -0,0 +1,143 @@
+import { WriteStream } from 'fs';
+
+import { Repository } from './repository';
+import { Blob } from './blob';
+import { Buf } from './buf';
+
+export namespace Filter {
+    const enum FLAG {
+        DEFAULT = 0,
+        ALLOW_UNSAFE = 1
+    }
+
+    const enum MODE {
+        TO_WORKTREE = 0,
+        SMUDGE = 0,
+        TO_ODB = 1,
+        CLEAN = 1
+    }
+}
+
+export class Filter {
+    /**
+     *
+     *
+     * @static
+     * @param {*} filters
+     * @param {string} name
+     * @returns {number}
+     *
+     * @memberof Filter
+     */
+    static listContains(filters: any, name: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {*} fl
+     * @returns {number}
+     *
+     * @memberof Filter
+     */
+    static listLength(fl: any): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {number} mode
+     * @param {number} options
+     * @returns {Promise<any>}
+     *
+     * @memberof Filter
+     */
+    static listNew(repo: Repository, mode: number, options: number): Promise<any>;
+    /**
+     *
+     *
+     * @static
+     * @param {*} filters
+     * @param {Blob} blob
+     * @param {WriteStream} target
+     * @returns {number}
+     *
+     * @memberof Filter
+     */
+    static listStreamBlob(filters: any, blob: Blob, target: WriteStream): number;
+    /**
+     *
+     *
+     * @static
+     * @param {*} filters
+     * @param {Buf} data
+     * @param {WriteStream} target
+     * @returns {number}
+     *
+     * @memberof Filter
+     */
+    static listStreamData(filters: any, data: Buf, target: WriteStream): number;
+    /**
+     *
+     *
+     * @static
+     * @param {*} filters
+     * @param {Repository} repo
+     * @param {string} path
+     * @param {WriteStream} target
+     * @returns {number}
+     *
+     * @memberof Filter
+     */
+    static listStreamFile(filters: any, repo: Repository, path: string, target: WriteStream): number;
+    /**
+     *
+     *
+     * @static
+     * @param {string} name
+     * @returns {number}
+     *
+     * @memberof Filter
+     */
+    static unregister(name: string): number;
+
+    /**
+     *
+     *
+     * @param {string} name
+     * @returns {Filter}
+     *
+     * @memberof Filter
+     */
+    lookup(name: string): Filter;
+    /**
+     *
+     *
+     * @param {string} name
+     * @param {number} priority
+     * @returns {number}
+     *
+     * @memberof Filter
+     */
+    register(name: string, priority: number): number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof Filter
+     */
+    version: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof Filter
+     */
+    attributes: string;
+    /**
+     *
+     *
+     * @type {Function}
+     * @memberof Filter
+     */
+    stream: Function;
+}

types/nodegit/git-err.d.ts

@@ -0,0 +1,39 @@
+import { Error } from './error';
+
+export class Giterr {
+    /**
+     *
+     *
+     * @static
+     *
+     * @memberof Giterr
+     */
+    static errClear(): void;
+    /**
+     *
+     *
+     * @static
+     * @returns {Error}
+     *
+     * @memberof Giterr
+     */
+    static errLast(): Error;
+    /**
+     *
+     *
+     * @static
+     *
+     * @memberof Giterr
+     */
+    static errSetOom(): void;
+    /**
+     *
+     *
+     * @static
+     * @param {number} errorClass
+     * @param {string} string
+     *
+     * @memberof Giterr
+     */
+    static errSetString(errorClass: number, string: string): void;
+}

types/nodegit/graph.d.ts

@@ -0,0 +1,29 @@
+import { Repository } from './repository';
+import { Oid } from './oid';
+
+export class Graph {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Oid} local
+     * @param {Oid} upstream
+     * @returns {Promise<number>}
+     *
+     * @memberof Graph
+     */
+    static aheadBehind(repo: Repository, local: Oid, upstream: Oid): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Oid} commit
+     * @param {Oid} ancestor
+     * @returns {Promise<number>}
+     *
+     * @memberof Graph
+     */
+    static descendantOf(repo: Repository, commit: Oid, ancestor: Oid): Promise<number>;
+}

types/nodegit/hash-sig.d.ts

@@ -0,0 +1,51 @@
+export namespace Hashsig {
+    const enum OPTION {
+        NORMAL = 0,
+        IGNORE_WHITESPACE = 1,
+        SMART_WHITESPACE = 2,
+        ALLOW_SMALL_FILES = 4
+    }
+}
+
+export class Hashsig {
+    /**
+     *
+     *
+     * @static
+     * @param {string} buf
+     * @param {number} buflen
+     * @param {number} opts
+     * @returns {Promise<Hashsig>}
+     *
+     * @memberof Hashsig
+     */
+    static create(buf: string, buflen: number, opts: number): Promise<Hashsig>;
+    /**
+     *
+     *
+     * @static
+     * @param {string} path
+     * @param {number} opts
+     * @returns {Promise<Hashsig>}
+     *
+     * @memberof Hashsig
+     */
+    static createFromFile(path: string, opts: number): Promise<Hashsig>;
+
+    /**
+     *
+     *
+     * @param {Hashsig} b
+     * @returns {number}
+     *
+     * @memberof Hashsig
+     */
+    compare(b: Hashsig): number;
+    /**
+     *
+     *
+     *
+     * @memberof Hashsig
+     */
+    free(): void;
+}

types/nodegit/ignore.d.ts

@@ -0,0 +1,36 @@
+import { Repository } from './repository';
+
+export class Ignore {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} rules
+     * @returns {number}
+     *
+     * @memberof Ignore
+     */
+    static addRule(repo: Repository, rules: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @returns {number}
+     *
+     * @memberof Ignore
+     */
+    static clearInternalRules(repo: Repository): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} path
+     * @returns {Promise<number>}
+     *
+     * @memberof Ignore
+     */
+    static pathIsIgnored(repo: Repository, path: string): Promise<number>;
+}

types/nodegit/index-entry.d.ts

@@ -0,0 +1,105 @@
+import { Oid } from './oid';
+
+export interface IndexTime {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof IndexTime
+     */
+    seconds: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof IndexTime
+     */
+    nanoseconds: number;
+}
+
+export class IndexEntry {
+    /**
+     *
+     *
+     * @type {IndexTime}
+     * @memberof IndexEntry
+     */
+    ctime: IndexTime;
+    /**
+     *
+     *
+     * @type {IndexTime}
+     * @memberof IndexEntry
+     */
+    mtime: IndexTime;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof IndexEntry
+     */
+    dev: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof IndexEntry
+     */
+    ino: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof IndexEntry
+     */
+    mode: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof IndexEntry
+     */
+    uid: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof IndexEntry
+     */
+    gid: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof IndexEntry
+     */
+    fileSize: number;
+    /**
+     *
+     *
+     * @type {Oid}
+     * @memberof IndexEntry
+     */
+    id: Oid;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof IndexEntry
+     */
+    flags: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof IndexEntry
+     */
+    flagsExtended: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof IndexEntry
+     */
+    path: string;
+}

types/nodegit/index.d.ts

@@ -0,0 +1,103 @@
+// Type definitions for nodegit 0.18
+// Project: https://github.com/nodegit/nodegit
+// Definitions by: Dolan Miu <https://github.com/dolanmiu>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export { AnnotatedCommit } from './annotated-commit';
+export { Attr } from './attr';
+export { BlameHunk } from './blame-hunk';
+export { BlameOptions } from './blame-options';
+export { Blame } from './blame';
+export { Blob } from './blob';
+export { Branch } from './branch';
+export { Buf } from './buf';
+export { CertHostkey } from './cert-host-key';
+export { CertX509 } from './cert-x509';
+export { Cert } from './cert';
+export { CheckoutOptions } from './checkout-options';
+export { Checkout } from './checkout';
+export { CherrypickOptions } from './cherry-pick-options';
+export { Cherrypick } from './cherry-pick';
+export { CloneOptions } from './clone-options';
+export { Clone } from './clone';
+export { Commit } from './commit';
+export { Config } from './config';
+export { ConvenientPatch } from './convenient-patch';
+export { CredUserpassPayload } from './cred-user-pass-payload';
+export { CredUsername } from './cred-username';
+export { Cred } from './cred';
+export { CvarMap } from './cvar-map';
+export { DescribeFormatOptions } from './describe-format-options';
+export { DescribeOptions } from './describe-options';
+export { DiffBinaryFile } from './diff-binary-file';
+export { DiffBinary } from './diff-binary';
+export { DiffDelta } from './diff-delta';
+export { DiffFile } from './diff-file';
+export { DiffHunk } from './diff-hunk';
+export { DiffLine } from './diff-line';
+export { DiffOptions } from './diff-options';
+export { DiffPerfdata } from './diff-perf-data';
+export { Diff, DiffFindOptions } from './diff';
+export { Enums } from './enums';
+export { Error } from './error';
+export { FetchOptions } from './fetch-options';
+export { Fetch } from './fetch';
+export { Filter } from './filter';
+export { Giterr } from './git-err';
+export { Graph } from './graph';
+export { Hashsig } from './hash-sig';
+export { Index } from './index_';
+export { IndexEntry } from './index-entry';
+export { Ignore } from './ignore';
+export { Indexer } from './indexer';
+export { Libgit2 } from './lib-git2';
+export { MergeFileInput } from './merge-file-input';
+export { MergeFileOptions } from './merge-file-options';
+export { MergeFileResult } from './merge-file-result';
+export { MergeOptions } from './merge-options';
+export { Merge } from './merge';
+export { Note } from './note';
+export { Object } from './object';
+export { OdbExpandId } from './odb-expand-id';
+export { OdbObject } from './odb-object';
+export { Odb } from './odb';
+export { Oidarray } from './oid-array';
+export { Oid } from './oid';
+export { Openssl } from './open-ssl';
+export { Packbuilder } from './pack-builder';
+export { Pathspec } from './path-spec';
+export { ProxyOptions } from './proxy-options';
+export { Proxy } from './proxy';
+export { PushOptions } from './push-options';
+export { PushUpdate } from './push-update';
+export { Push } from './push';
+export { RebaseOperation } from './rebase-operation';
+export { Rebase, RebaseOptions } from './rebase';
+export { Refdb } from './ref-db';
+export { Reflog, ReflogEntry } from './ref-log';
+export { Refspec } from './ref-spec';
+export { Reference } from './reference';
+export { RemoteCallbacks } from './remote-callbacks';
+export { Remote } from './remote';
+export { Repository } from './repository';
+export { Reset } from './reset';
+export { Revparse } from './rev-parse';
+export { Revwalk } from './rev-walk';
+export { Revert } from './revert';
+export { Signature } from './signature';
+export { Stash } from './stash';
+export { StatusEntry } from './status-entry';
+export { StatusList } from './status-list';
+export { StatusOptions } from './status-options';
+export { Status } from './status';
+export { Strarray } from './str-array';
+export { SubmoduleUpdateOptions } from './submodule-update-options';
+export { Submodule } from './submodule';
+export { Tag } from './tag';
+export { Time } from './time';
+export { TransferProgress } from './transfer-progress';
+export { Transport } from './transport';
+export { Treebuilder } from './tree-builder';
+export { TreeEntry } from './tree-entry';
+export { TreeUpdate } from './tree-update';
+export { Tree } from './tree';

types/nodegit/index_.d.ts

@@ -0,0 +1,335 @@
+import { Oid } from './oid';
+import { IndexEntry } from './index-entry';
+import { Repository } from './repository';
+import { Tree } from './tree';
+import { Strarray } from './str-array';
+
+export namespace Index {
+    const enum ADD_OPTION {
+        ADD_DEFAULT = 0,
+        ADD_FORCE = 1,
+        ADD_DISABLE_PATHSPEC_MATCH = 2,
+        ADD_CHECK_PATHSPEC = 4
+    }
+
+    const enum CAP {
+        IGNORE_CASE = 1,
+        NO_FILEMODE = 2,
+        NO_SYMLINKS = 4,
+        FROM_OWNER = -1
+    }
+}
+
+export class Index {
+    /**
+     *
+     *
+     * @static
+     * @param {IndexEntry} entry
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    static entryIsConflict(entry: IndexEntry): number;
+    /**
+     *
+     *
+     * @static
+     * @param {IndexEntry} entry
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    static entryStage(entry: IndexEntry): number;
+    /**
+     *
+     *
+     * @static
+     * @param {string} indexPath
+     * @returns {Promise<Index>}
+     *
+     * @memberof Index
+     */
+    static open(indexPath: string): Promise<Index>;
+
+    /**
+     *
+     *
+     * @param {IndexEntry} sourceEntry
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    add(sourceEntry: IndexEntry): number;
+    /**
+     *
+     *
+     * @param {Strarray} pathspec
+     * @param {number} flags
+     * @param {Function} callback
+     * @param {void} payload
+     * @returns {Promise<number>}
+     *
+     * @memberof Index
+     */
+    addAll(pathspec: Strarray, flags: number, callback: Function, payload: void): Promise<number>;
+    /**
+     *
+     *
+     * @param {string} path
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    addByPath(path: string): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    caps(): number;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Index
+     */
+    checksum(): Oid;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    clear(): number;
+    /**
+     *
+     *
+     * @param {IndexEntry} ancestorEntry
+     * @param {IndexEntry} ourEntry
+     * @param {IndexEntry} theirEntry
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    conflictAdd(ancestorEntry: IndexEntry, ourEntry: IndexEntry, theirEntry: IndexEntry): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    conflictCleanup(): number;
+    /**
+     *
+     *
+     * @param {string} path
+     * @returns {Promise<IndexEntry>}
+     *
+     * @memberof Index
+     */
+    conflictGet(path: string): Promise<IndexEntry>;
+    /**
+     *
+     *
+     * @param {string} path
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    conflictRemove(path: string): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    entryCount(): number;
+    /**
+     *
+     *
+     * @param {number} n
+     * @returns {IndexEntry}
+     *
+     * @memberof Index
+     */
+    getByIndex(n: number): IndexEntry;
+    /**
+     *
+     *
+     * @param {string} path
+     * @param {number} stage
+     * @returns {IndexEntry}
+     *
+     * @memberof Index
+     */
+    getByPath(path: string, stage: number): IndexEntry;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    hasConflicts(): number;
+    /**
+     *
+     *
+     * @returns {Repository}
+     *
+     * @memberof Index
+     */
+    owner(): Repository;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Index
+     */
+    path(): string;
+    /**
+     *
+     *
+     * @param {number} force
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    read(force: number): number;
+    /**
+     *
+     *
+     * @param {Tree} tree
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    readTree(tree: Tree): number;
+    /**
+     *
+     *
+     * @param {string} path
+     * @param {number} stage
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    remove(path: string, stage: number): number;
+    /**
+     *
+     *
+     * @param {Strarray} pathspec
+     * @param {Function} callback
+     * @param {void} payload
+     * @returns {Promise<number>}
+     *
+     * @memberof Index
+     */
+    removeAll(pathspec: Strarray, callback: Function, payload: void): Promise<number>;
+    /**
+     *
+     *
+     * @param {string} path
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    removeByPath(path: string): number;
+    /**
+     *
+     *
+     * @param {string} dir
+     * @param {number} stage
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    removeDirectory(dir: string, stage: number): number;
+    /**
+     *
+     *
+     * @param {number} caps
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    setCaps(caps: number): number;
+    /**
+     *
+     *
+     * @param {Strarray} pathspec
+     * @param {Function} callback
+     * @param {void} payload
+     * @returns {Promise<number>}
+     *
+     * @memberof Index
+     */
+    updateAll(pathspec: Strarray, callback: Function, payload: void): Promise<number>;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    write(): number;
+    /**
+     *
+     *
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Index
+     */
+    writeTree(): Promise<Oid>;
+    /**
+     *
+     *
+     * @param {Repository} repo
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Index
+     */
+    writeTreeTo(repo: Repository): Promise<Oid>;
+    /**
+     *
+     *
+     * @returns {IndexEntry[]}
+     *
+     * @memberof Index
+     */
+    entries(): IndexEntry[];
+    /**
+     *
+     *
+     * @param {number} atPos
+     * @param {string} prefix
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    findPrefix(atPos: number, prefix: string): number;
+    /**
+     *
+     *
+     * @param {number} version
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    setVersion(version: number): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Index
+     */
+    version(): number;
+}

types/nodegit/indexer.d.ts

@@ -0,0 +1,29 @@
+import { TransferProgress } from './transfer-progress';
+import { Oid } from './oid';
+
+export class Indexer {
+    /**
+     *
+     *
+     * @param {TransferProgress} stats
+     * @returns {number}
+     *
+     * @memberof Indexer
+     */
+    commit(stats: TransferProgress): number;
+    /**
+     *
+     *
+     *
+     * @memberof Indexer
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Indexer
+     */
+    hash(): Oid;
+}

types/nodegit/lib-git2.d.ts

@@ -0,0 +1,68 @@
+export namespace Libgit2 {
+    const enum OPT {
+        GET_MWINDOW_SIZE = 0,
+        SET_MWINDOW_SIZE = 1,
+        GET_MWINDOW_MAPPED_LIMIT = 2,
+        SET_MWINDOW_MAPPED_LIMIT = 3,
+        GET_SEARCH_PATH = 4,
+        SET_SEARCH_PATH = 5,
+        SET_CACHE_OBJECT_LIMIT = 6,
+        SET_CACHE_MAX_SIZE = 7,
+        ENABLE_CACHING = 8,
+        GET_CACHED_MEMORY = 9,
+        GET_TEMPLATE_PATH = 10,
+        SET_TEMPLATE_PATH = 11,
+        SET_SSL_CERT_LOCATIONS = 12
+    }
+}
+
+export class Libgit2 {
+    /**
+     *
+     *
+     * @static
+     * @returns {number}
+     *
+     * @memberof Libgit2
+     */
+    static features(): number;
+    /**
+     *
+     *
+     * @static
+     * @returns {number}
+     *
+     * @memberof Libgit2
+     */
+    static init(): number;
+    /**
+     *
+     *
+     * @static
+     * @param {number} option
+     * @returns {number}
+     *
+     * @memberof Libgit2
+     */
+    static opts(option: number): number;
+    /**
+     *
+     *
+     * @static
+     * @returns {number}
+     *
+     * @memberof Libgit2
+     */
+    static shutdown(): number;
+    /**
+     *
+     *
+     * @static
+     * @param {number} major
+     * @param {number} minor
+     * @param {number} rev
+     *
+     * @memberof Libgit2
+     */
+    static version(major: number, minor: number, rev: number): void;
+}

types/nodegit/merge-file-input.d.ts

@@ -0,0 +1,37 @@
+export interface MergeFileInput {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeFileInput
+     */
+    version: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof MergeFileInput
+     */
+    ptr: string;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeFileInput
+     */
+    size: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof MergeFileInput
+     */
+    path: string;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeFileInput
+     */
+    mode: number;
+}

types/nodegit/merge-file-options.d.ts

@@ -0,0 +1,44 @@
+export interface MergeFileOptions {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeFileOptions
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof MergeFileOptions
+     */
+    ancestorLabel?: string;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof MergeFileOptions
+     */
+    ourLabel?: string;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof MergeFileOptions
+     */
+    theirLabel?: string;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeFileOptions
+     */
+    favor?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeFileOptions
+     */
+    flags?: number;
+}

types/nodegit/merge-file-result.d.ts

@@ -0,0 +1,37 @@
+export class MergeFileResult {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeFileResult
+     */
+    automergeable: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof MergeFileResult
+     */
+    path: string;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeFileResult
+     */
+    mode: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof MergeFileResult
+     */
+    ptr: string;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeFileResult
+     */
+    len: number;
+}

types/nodegit/merge-options.d.ts

@@ -0,0 +1,58 @@
+export class MergeOptions {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeOptions
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeOptions
+     */
+    renameThreshold?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeOptions
+     */
+    targetLimit?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeOptions
+     */
+    fileFavor?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeOptions
+     */
+    fileFlags?: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof MergeOptions
+     */
+    defaultDriver?: string;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeOptions
+     */
+    flags?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof MergeOptions
+     */
+    recursionLimit?: number;
+}

types/nodegit/merge.d.ts

@@ -0,0 +1,138 @@
+import { Repository } from './repository';
+import { Oid } from './oid';
+import { Tree } from './tree';
+import { Commit } from './commit';
+import { Index } from './index';
+import { AnnotatedCommit } from './annotated-commit';
+import { CheckoutOptions } from './checkout-options';
+import { Oidarray } from './oid-array';
+import { MergeOptions } from './merge-options';
+import { MergeFileInput } from './merge-file-input';
+
+export namespace Merge {
+    const enum ANALYSIS {
+        NONE = 0,
+        NORMAL = 1,
+        UP_TO_DATE = 2,
+        FASTFORWARD = 4,
+        UNBORN = 8
+    }
+
+    const enum FILE_FAVOR {
+        NORMAL = 0,
+        OURS = 1,
+        THEIRS = 2,
+        UNION = 3
+    }
+
+    const enum FILE_FLAGS {
+        FILE_DEFAULT = 0,
+        FILE_STYLE_MERGE = 1,
+        FILE_STYLE_DIFF3 = 2,
+        FILE_SIMPLIFY_ALNUM = 4,
+        FILE_IGNORE_WHITESPACE = 8,
+        FILE_IGNORE_WHITESPACE_CHANGE = 16,
+        FILE_IGNORE_WHITESPACE_EOL = 32,
+        FILE_DIFF_PATIENCE = 64,
+        FILE_DIFF_MINIMAL = 128
+    }
+
+    const enum PREFERENCE {
+        NONE = 0,
+        NO_FASTFORWARD = 1,
+        FASTFORWARD_ONLY = 2
+    }
+
+    const enum TREE_FLAG {
+        TREE_FIND_RENAMES = 1
+    }
+}
+
+export class Merge {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {AnnotatedCommit} theirHead
+     * @param {MergeOptions} [mergeOpts]
+     * @param {CheckoutOptions} [checkoutOpts]
+     * @returns {*}
+     *
+     * @memberof Merge
+     */
+    static merge(repo: Repository, theirHead: AnnotatedCommit, mergeOpts?: MergeOptions, checkoutOpts?: CheckoutOptions): any;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Oid} one
+     * @param {Oid} two
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Merge
+     */
+    static base(repo: Repository, one: Oid, two: Oid): Promise<Oid>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Oid} one
+     * @param {Oid} two
+     * @returns {Promise<Oidarray>}
+     *
+     * @memberof Merge
+     */
+    static bases(repo: Repository, one: Oid, two: Oid): Promise<Oidarray>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Commit} ourCommit
+     * @param {Commit} theirCommit
+     * @param {MergeOptions} [options]
+     * @returns {*}
+     *
+     * @memberof Merge
+     */
+    static commits(repo: Repository, ourCommit: Commit, theirCommit: Commit, options?: MergeOptions): any;
+    /**
+     *
+     *
+     * @static
+     * @param {MergeFileInput} opts
+     * @param {number} version
+     * @returns {number}
+     *
+     * @memberof Merge
+     */
+    static fileInitInput(opts: MergeFileInput, version: number): number;
+    /**
+     *
+     *
+     * @static
+     * @param {MergeOptions} opts
+     * @param {number} version
+     * @returns {number}
+     *
+     * @memberof Merge
+     */
+    static initOptions(opts: MergeOptions, version: number): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Tree} ancestorTree
+     * @param {Tree} ourTree
+     * @param {Tree} theirTree
+     * @param {MergeOptions} opts
+     * @returns {Promise<Index>}
+     *
+     * @memberof Merge
+     */
+    static trees(repo: Repository, ancestorTree: Tree, ourTree: Tree, theirTree: Tree, opts: MergeOptions): Promise<Index>;
+}

types/nodegit/nodegit-tests.ts

@@ -0,0 +1,53 @@
+import * as Git from 'nodegit';
+
+Git.Repository.discover("startPath", 1, "ceilingDirs").then((string) => {
+    // Use string
+});
+
+Git.Repository.init("path", true).then((repository) => {
+    // Use repository
+});
+
+const repo = new Git.Repository();
+const id = new Git.Oid();
+const ref = new Git.Reference();
+
+// AnnotatedCommit Tests
+
+Git.AnnotatedCommit.fromFetchhead(repo, "branch_name", "remote_url", id).then((annotatedCommit) => {
+    // Use annotatedCommit
+});
+
+Git.AnnotatedCommit.fromRef(repo, ref).then((annotatedCommit) => {
+    // Use annotatedCommit
+});
+
+Git.AnnotatedCommit.fromRevspec(repo, "revspec").then((annotatedCommit) => {
+    // Use annotatedCommit
+});
+
+Git.AnnotatedCommit.lookup(repo, id).then((annotatedCommit) => {
+    // Use annotatedCommit
+    annotatedCommit.free();
+    annotatedCommit.id();
+});
+
+// Attr tests
+
+let result = Git.Attr.addMacro(repo, "name", "values");
+
+Git.Attr.cacheFlush(repo);
+
+Git.Attr.get(repo, 1, "path", "name").then((string) => {
+    // Use string
+});
+
+let array = Git.Attr.getMany(repo, 1, "path", 1, "names");
+
+result = Git.Attr.value("attr");
+
+const blameOptions = new Git.BlameOptions();
+
+Git.Branch.lookup(repo, "branch_name", Git.Branch.BRANCH.LOCAL).then((reference) => {
+    // Use reference
+});

types/nodegit/note.d.ts

@@ -0,0 +1,124 @@
+import {Repository} from './repository';
+import {Signature} from './signature';
+import {Oid} from './oid';
+
+export class Note {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} notesRef
+     * @param {Signature} author
+     * @param {Signature} committer
+     * @param {Oid} oid
+     * @param {string} note
+     * @param {number} force
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Note
+     */
+    static create(repo: Repository, notesRef: string, author: Signature, committer: Signature, oid: Oid, note: string, force: number): Promise<Oid>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} notesRef
+     * @param {Function} noteCb
+     * @param {*} payload
+     * @returns {Promise<number>}
+     *
+     * @memberof Note
+     */
+    static foreach(repo: Repository, notesRef: string, noteCb: Function, payload: any): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} notesRef
+     * @returns {Promise<any>}
+     *
+     * @memberof Note
+     */
+    static iteratorNew(repo: Repository, notesRef: string): Promise<any>;
+    /**
+     *
+     *
+     * @static
+     * @param {Oid} noteId
+     * @param {Oid} annotatedId
+     * @param {*} it
+     * @returns {number}
+     *
+     * @memberof Note
+     */
+    static next(noteId: Oid, annotatedId: Oid, it: any): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} notesRef
+     * @param {Oid} oid
+     * @returns {Promise<Note>}
+     *
+     * @memberof Note
+     */
+    static read(repo: Repository, notesRef: string, oid: Oid): Promise<Note>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} notesRef
+     * @param {Signature} author
+     * @param {Signature} committer
+     * @param {Oid} oid
+     * @returns {Promise<number>}
+     *
+     * @memberof Note
+     */
+    static remove(repo: Repository, notesRef: string, author: Signature, committer: Signature, oid: Oid): Promise<number>;
+
+    /**
+     *
+     *
+     * @returns {Signature}
+     *
+     * @memberof Note
+     */
+    author(): Signature;
+    /**
+     *
+     *
+     * @returns {Signature}
+     *
+     * @memberof Note
+     */
+    committer(): Signature;
+    /**
+     *
+     *
+     *
+     * @memberof Note
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Note
+     */
+    id(): Oid;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Note
+     */
+    message(): string;
+}

types/nodegit/object.d.ts

@@ -0,0 +1,138 @@
+import { Oid } from './oid';
+import { Repository } from './repository';
+import { Buf } from './buf';
+
+export class Object {
+    /**
+     *
+     *
+     * @static
+     * @param {number} type
+     * @returns {number}
+     *
+     * @memberof Object
+     */
+    static size(type: number): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Oid} id
+     * @param {number} type
+     * @returns {Promise<Object>}
+     *
+     * @memberof Object
+     */
+    static lookup(repo: Repository, id: Oid, type: number): Promise<Object>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Oid} id
+     * @param {number} len
+     * @param {number} type
+     * @returns {Promise<Object>}
+     *
+     * @memberof Object
+     */
+    static lookupPrefix(repo: Repository, id: Oid, len: number, type: number): Promise<Object>;
+    /**
+     *
+     *
+     * @static
+     * @param {string} str
+     * @returns {number}
+     *
+     * @memberof Object
+     */
+    static string2type(str: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {number} type
+     * @returns {string}
+     *
+     * @memberof Object
+     */
+    static type2string(type: number): string;
+    /**
+     *
+     *
+     * @static
+     * @param {number} type
+     * @returns {number}
+     *
+     * @memberof Object
+     */
+    static typeisloose(type: number): number;
+
+    /**
+     *
+     *
+     * @returns {Promise<Object>}
+     *
+     * @memberof Object
+     */
+    dup(): Promise<Object>;
+    /**
+     *
+     *
+     *
+     * @memberof Object
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Object
+     */
+    id(): Oid;
+    /**
+     *
+     *
+     * @param {string} path
+     * @param {number} type
+     * @returns {Promise<Object>}
+     *
+     * @memberof Object
+     */
+    lookupByPath(path: string, type: number): Promise<Object>;
+    /**
+     *
+     *
+     * @returns {Repository}
+     *
+     * @memberof Object
+     */
+    owner(): Repository;
+    /**
+     *
+     *
+     * @param {number} targetType
+     * @returns {Promise<Object>}
+     *
+     * @memberof Object
+     */
+    peel(targetType: number): Promise<Object>;
+    /**
+     *
+     *
+     * @returns {Promise<Buf>}
+     *
+     * @memberof Object
+     */
+    shortId(): Promise<Buf>;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Object
+     */
+    type(): number;
+}

types/nodegit/odb-expand-id.d.ts

@@ -0,0 +1,7 @@
+import { Oid } from './oid';
+
+export class OdbExpandId {
+    id: Oid;
+    length: number;
+    type: number;
+}

types/nodegit/odb-object.d.ts

@@ -0,0 +1,51 @@
+import { Oid } from './oid';
+
+export class OdbObject {
+    /**
+     *
+     *
+     * @returns {Buffer}
+     *
+     * @memberof OdbObject
+     */
+    data(): Buffer;
+    /**
+     *
+     *
+     * @returns {Promise<OdbObject>}
+     *
+     * @memberof OdbObject
+     */
+    dup(): Promise<OdbObject>;
+    /**
+     *
+     *
+     *
+     * @memberof OdbObject
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof OdbObject
+     */
+    id(): Oid;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof OdbObject
+     */
+    size(): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof OdbObject
+     */
+    type(): number;
+}

types/nodegit/odb.d.ts

@@ -0,0 +1,71 @@
+import { Oid } from './oid';
+import { OdbObject } from './odb-object';
+import { OdbExpandId } from './odb-expand-id';
+
+export namespace Odb {
+    const enum STREAM {
+        RDONLY = 2,
+        WRONLY = 4,
+        RW = 6
+    }
+}
+
+export class Odb {
+    /**
+     *
+     *
+     * @static
+     * @param {string} objectsDir
+     * @returns {Promise<Odb>}
+     *
+     * @memberof Odb
+     */
+    static open(objectsDir: string): Promise<Odb>;
+
+    /**
+     *
+     *
+     * @param {string} path
+     * @returns {number}
+     *
+     * @memberof Odb
+     */
+    addDiskAlternate(path: string): number;
+    /**
+     *
+     *
+     *
+     * @memberof Odb
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @param {Oid} id
+     * @returns {Promise<OdbObject>}
+     *
+     * @memberof Odb
+     */
+    read(id: Oid): Promise<OdbObject>;
+    /**
+     *
+     *
+     * @param {Buffer} data
+     * @param {number} len
+     * @param {number} type
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Odb
+     */
+    write(data: Buffer, len: number, type: number): Promise<Oid>;
+    /**
+     *
+     *
+     * @param {OdbExpandId} ids
+     * @param {number} count
+     * @returns {number}
+     *
+     * @memberof Odb
+     */
+    expandIds(ids: OdbExpandId, count: number): number;
+}

types/nodegit/oid-array.d.ts

@@ -0,0 +1,25 @@
+import { Oid } from './oid';
+
+export class Oidarray {
+    /**
+     *
+     *
+     *
+     * @memberof Oidarray
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @type {Oid}
+     * @memberof Oidarray
+     */
+    ids: Oid;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof Oidarray
+     */
+    count: number;
+}

types/nodegit/oid.d.ts

@@ -0,0 +1,73 @@
+export class Oid {
+    static fromString(str: string): Oid;
+    /**
+     *
+     *
+     * @param {Oid} b
+     * @returns {number}
+     *
+     * @memberof Oid
+     */
+    cmp(b: Oid): number;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Oid
+     */
+    cpy(): Oid;
+    /**
+     *
+     *
+     * @param {Oid} b
+     * @returns {number}
+     *
+     * @memberof Oid
+     */
+    equal(b: Oid): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Oid
+     */
+    iszero(): number;
+    /**
+     *
+     *
+     * @param {Oid} b
+     * @param {number} len
+     * @returns {number}
+     *
+     * @memberof Oid
+     */
+    ncmp(b: Oid, len: number): number;
+    /**
+     *
+     *
+     * @param {string} str
+     * @returns {number}
+     *
+     * @memberof Oid
+     */
+    strcmp(str: string): number;
+    /**
+     *
+     *
+     * @param {string} str
+     * @returns {number}
+     *
+     * @memberof Oid
+     */
+    streq(str: string): number;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Oid
+     */
+    tostrS(): string;
+}

types/nodegit/open-ssl.d.ts

@@ -0,0 +1,11 @@
+export class Openssl {
+    /**
+     *
+     *
+     * @static
+     * @returns {number}
+     *
+     * @memberof Openssl
+     */
+    static setLocking(): number;
+}

types/nodegit/pack-builder.d.ts

@@ -0,0 +1,111 @@
+import { Repository } from './repository';
+import { Oid } from './oid';
+import { Revwalk } from './rev-walk';
+
+export namespace Packbuilder {
+    const enum STAGE {
+        ADDING_OBJECTS = 0,
+        DELTAFICATION = 1
+    }
+}
+
+export class Packbuilder {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @returns {Packbuilder}
+     *
+     * @memberof Packbuilder
+     */
+    static create(repo: Repository): Packbuilder;
+
+    /**
+     *
+     *
+     *
+     * @memberof Packbuilder
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Packbuilder
+     */
+    hash(): Oid;
+    /**
+     *
+     *
+     * @param {Oid} id
+     * @param {string} name
+     * @returns {number}
+     *
+     * @memberof Packbuilder
+     */
+    insert(id: Oid, name: string): number;
+    /**
+     *
+     *
+     * @param {Oid} id
+     * @returns {number}
+     *
+     * @memberof Packbuilder
+     */
+    insertCommit(id: Oid): number;
+    /**
+     *
+     *
+     * @param {Oid} id
+     * @param {string} name
+     * @returns {number}
+     *
+     * @memberof Packbuilder
+     */
+    insertRecur(id: Oid, name: string): number;
+    /**
+     *
+     *
+     * @param {Oid} id
+     * @returns {number}
+     *
+     * @memberof Packbuilder
+     */
+    insertTree(id: Oid): number;
+    /**
+     *
+     *
+     * @param {Revwalk} walk
+     * @returns {number}
+     *
+     * @memberof Packbuilder
+     */
+    insertWalk(walk: Revwalk): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Packbuilder
+     */
+    objectCount(): number;
+    /**
+     *
+     *
+     * @param {number} n
+     * @returns {number}
+     *
+     * @memberof Packbuilder
+     */
+    setThreads(n: number): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Packbuilder
+     */
+    written(): number;
+}

types/nodegit/path-spec.d.ts

@@ -0,0 +1,142 @@
+import { DiffDelta } from './diff-delta';
+import { Tree } from './tree';
+import { Diff } from './diff';
+import { Repository } from './repository';
+import { Index } from './index';
+import { Strarray } from './str-array';
+
+export namespace Pathspec {
+    const enum FLAG {
+        DEFAULT = 0,
+        IGNORE_CASE = 1,
+        USE_CASE = 2,
+        NO_GLOB = 4,
+        NO_MATCH_ERROR = 8,
+        FIND_FAILURES = 16,
+        FAILURES_ONLY = 32
+    }
+}
+
+export class Pathspec {
+    /**
+     *
+     *
+     * @static
+     * @param {*} m
+     * @param {number} pos
+     * @returns {DiffDelta}
+     *
+     * @memberof Pathspec
+     */
+    static matchListDiffEntry(m: any, pos: number): DiffDelta;
+    /**
+     *
+     *
+     * @static
+     * @param {*} m
+     * @param {number} pos
+     * @returns {string}
+     *
+     * @memberof Pathspec
+     */
+    static matchListEntry(m: any, pos: number): string;
+    /**
+     *
+     *
+     * @static
+     * @param {*} m
+     * @returns {number}
+     *
+     * @memberof Pathspec
+     */
+    static matchListEntrycount(m: any): number;
+    /**
+     *
+     *
+     * @static
+     * @param {*} m
+     * @param {number} pos
+     * @returns {string}
+     *
+     * @memberof Pathspec
+     */
+    static matchListFailedEntry(m: any, pos: number): string;
+    /**
+     *
+     *
+     * @static
+     * @param {*} m
+     * @returns {number}
+     *
+     * @memberof Pathspec
+     */
+    static matchListFailedEntrycount(m: any): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Strarray} pathspec
+     * @returns {Pathspec}
+     *
+     * @memberof Pathspec
+     */
+    static create(pathspec: Strarray): Pathspec;
+
+    /**
+     *
+     *
+     *
+     * @memberof Pathspec
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @param {Diff} diff
+     * @param {number} flags
+     * @returns {Promise<any>}
+     *
+     * @memberof Pathspec
+     */
+    matchDiff(diff: Diff, flags: number): Promise<any>;
+    /**
+     *
+     *
+     * @param {Index} index
+     * @param {number} flags
+     * @returns {Promise<any>}
+     *
+     * @memberof Pathspec
+     */
+    matchIndex(index: Index, flags: number): Promise<any>;
+    /**
+     *
+     *
+     * @param {Tree} tree
+     * @param {number} flags
+     * @returns {Promise<any>}
+     *
+     * @memberof Pathspec
+     */
+    matchTree(tree: Tree, flags: number): Promise<any>;
+    /**
+     *
+     *
+     * @param {Repository} repo
+     * @param {number} flags
+     * @returns {Promise<any>}
+     *
+     * @memberof Pathspec
+     */
+    matchWorkdir(repo: Repository, flags: number): Promise<any>;
+    /**
+     *
+     *
+     * @param {number} flags
+     * @param {string} path
+     * @returns {number}
+     *
+     * @memberof Pathspec
+     */
+    matchesPath(flags: number, path: string): number;
+}

types/nodegit/proxy-options.d.ts

@@ -0,0 +1,44 @@
+export class ProxyOptions {
+    /**
+     *
+     *
+     * @type {Function}
+     * @memberof ProxyOptions
+     */
+    certificateCheck?: Function;
+    /**
+     *
+     *
+     * @type {Function}
+     * @memberof ProxyOptions
+     */
+    credentials?: Function;
+    /**
+     *
+     *
+     * @type {*}
+     * @memberof ProxyOptions
+     */
+    payload?: any;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof ProxyOptions
+     */
+    type?: number;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof ProxyOptions
+     */
+    url?: string;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof ProxyOptions
+     */
+    version?: number;
+}

types/nodegit/proxy.d.ts

@@ -0,0 +1,5 @@
+import { ProxyOptions } from './proxy-options';
+
+export class Proxy {
+    static initOptions(opts: ProxyOptions, version: number): number;
+}

types/nodegit/push-options.d.ts

@@ -0,0 +1,41 @@
+import { RemoteCallbacks } from './remote-callbacks';
+import { Strarray } from './str-array';
+import { ProxyOptions } from './proxy-options';
+
+export interface PushOptions {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof PushOptions
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof PushOptions
+     */
+    pbParallelism?: number;
+    /**
+     *
+     *
+     * @type {RemoteCallbacks}
+     * @memberof PushOptions
+     */
+    callbacks?: RemoteCallbacks;
+    /**
+     *
+     *
+     * @type {Strarray}
+     * @memberof PushOptions
+     */
+    customHeaders: Strarray;
+    /**
+     *
+     *
+     * @type {ProxyOptions}
+     * @memberof PushOptions
+     */
+    proxyOpts: ProxyOptions;
+}

types/nodegit/push-update.d.ts

@@ -0,0 +1,32 @@
+import { Oid } from './oid';
+
+export class PushUpdate {
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof PushUpdate
+     */
+    srcRefname: string;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof PushUpdate
+     */
+    dstRefname: string;
+    /**
+     *
+     *
+     * @type {Oid}
+     * @memberof PushUpdate
+     */
+    src: Oid;
+    /**
+     *
+     *
+     * @type {Oid}
+     * @memberof PushUpdate
+     */
+    dst: Oid;
+}

types/nodegit/push.d.ts

@@ -0,0 +1,16 @@
+import { RemoteCallbacks } from './remote-callbacks';
+import { PushOptions } from './push-options';
+
+export class Push {
+    /**
+     *
+     *
+     * @static
+     * @param {PushOptions} opts
+     * @param {number} version
+     * @returns {number}
+     *
+     * @memberof Push
+     */
+    static initOptions(opts: PushOptions, version: number): number;
+}

types/nodegit/rebase-operation.d.ts

@@ -0,0 +1,36 @@
+import { Oid } from './oid';
+
+export namespace RebaseOperation {
+    const enum REBASE_OPERATION {
+        PICK = 0,
+        REWORD = 1,
+        EDIT = 2,
+        SQUASH = 3,
+        FIXUP = 4,
+        EXEC = 5
+    }
+}
+
+export class RebaseOperation {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof RebaseOperation
+     */
+    type: number;
+    /**
+     *
+     *
+     * @type {Oid}
+     * @memberof RebaseOperation
+     */
+    id: Oid;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof RebaseOperation
+     */
+    exec: string;
+}

types/nodegit/rebase.d.ts

@@ -0,0 +1,125 @@
+import { CheckoutOptions } from './checkout-options';
+import { AnnotatedCommit } from './annotated-commit';
+import { Repository } from './repository';
+import { Signature } from './signature';
+import { Oid } from './oid';
+import { RebaseOperation } from './rebase-operation';
+import { Index } from './index';
+
+export interface RebaseOptions {
+    version: number;
+    quiet: number;
+    rewriteNotesRef: string;
+    checkoutOptions: CheckoutOptions;
+}
+
+export class Rebase {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {AnnotatedCommit} branch
+     * @param {AnnotatedCommit} upstream
+     * @param {AnnotatedCommit} onto
+     * @param {RebaseOptions} opts
+     * @returns {Promise<Rebase>}
+     *
+     * @memberof Rebase
+     */
+    static init(repo: Repository, branch: AnnotatedCommit, upstream: AnnotatedCommit, onto: AnnotatedCommit, opts: RebaseOptions): Promise<Rebase>;
+    /**
+     *
+     *
+     * @static
+     * @param {RebaseOptions} opts
+     * @param {number} version
+     * @returns {number}
+     *
+     * @memberof Rebase
+     */
+    static initOptions(opts: RebaseOptions, version: number): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {RebaseOptions} opts
+     * @returns {Promise<Rebase>}
+     *
+     * @memberof Rebase
+     */
+    static open(repo: Repository, opts: RebaseOptions): Promise<Rebase>;
+
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Rebase
+     */
+    abort(): number;
+    /**
+     *
+     *
+     * @param {Signature} author
+     * @param {Signature} committer
+     * @param {string} messageEncoding
+     * @param {string} message
+     * @returns {Oid}
+     *
+     * @memberof Rebase
+     */
+    commit(author: Signature, committer: Signature, messageEncoding: string, message: string): Oid;
+    /**
+     *
+     *
+     * @param {Signature} signature
+     * @returns {number}
+     *
+     * @memberof Rebase
+     */
+    finish(signature: Signature): number;
+    /**
+     *
+     *
+     * @param {Index} index
+     * @returns {number}
+     *
+     * @memberof Rebase
+     */
+    inmemoryIndex(index: Index): number;
+    /**
+     *
+     *
+     * @returns {Promise<RebaseOperation>}
+     *
+     * @memberof Rebase
+     */
+    next(): Promise<RebaseOperation>;
+    /**
+     *
+     *
+     * @param {number} idx
+     * @returns {RebaseOperation}
+     *
+     * @memberof Rebase
+     */
+    operationByIndex(idx: number): RebaseOperation;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Rebase
+     */
+    operationCurrent(): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Rebase
+     */
+    operationEntrycount(): number;
+}

types/nodegit/ref-db.d.ts

@@ -0,0 +1,30 @@
+import { Repository } from './repository';
+
+export class Refdb {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @returns {Promise<Refdb>}
+     *
+     * @memberof Refdb
+     */
+    static open(repo: Repository): Promise<Refdb>;
+
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Refdb
+     */
+    compress(): number;
+    /**
+     *
+     *
+     *
+     * @memberof Refdb
+     */
+    free(): void;
+}

types/nodegit/ref-log.d.ts

@@ -0,0 +1,129 @@
+import { Repository } from './repository';
+import { Oid } from './oid';
+import { Signature } from './signature';
+
+export class Reflog {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @returns {number}
+     *
+     * @memberof Reflog
+     */
+    static delete(repo: Repository, name: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @returns {Promise<Reflog>}
+     *
+     * @memberof Reflog
+     */
+    static read(repo: Repository, name: string): Promise<Reflog>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} oldName
+     * @param {string} name
+     * @returns {number}
+     *
+     * @memberof Reflog
+     */
+    static rename(repo: Repository, oldName: string, name: string): number;
+
+    /**
+     *
+     *
+     * @param {Oid} id
+     * @param {Signature} committer
+     * @param {string} msg
+     * @returns {number}
+     *
+     * @memberof Reflog
+     */
+    append(id: Oid, committer: Signature, msg: string): number;
+    /**
+     *
+     *
+     * @param {number} idx
+     * @param {number} rewritePreviousEntry
+     * @returns {number}
+     *
+     * @memberof Reflog
+     */
+    drop(idx: number, rewritePreviousEntry: number): number;
+    /**
+     *
+     *
+     * @param {number} idx
+     * @returns {ReflogEntry}
+     *
+     * @memberof Reflog
+     */
+    entryByIndex(idx: number): ReflogEntry;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Reflog
+     */
+    entrycount(): number;
+    /**
+     *
+     *
+     *
+     * @memberof Reflog
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Reflog
+     */
+    write(): number;
+}
+
+export class ReflogEntry {
+    /**
+     *
+     *
+     * @returns {Signature}
+     *
+     * @memberof ReflogEntry
+     */
+    committer(): Signature;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof ReflogEntry
+     */
+    idNew(): Oid;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof ReflogEntry
+     */
+    idOld(): Oid;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof ReflogEntry
+     */
+    message(): string;
+}

types/nodegit/ref-spec.d.ts

@@ -0,0 +1,52 @@
+export class Refspec {
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Refspec
+     */
+    direction(): number;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Refspec
+     */
+    dst(): string;
+    /**
+     *
+     *
+     * @param {string} refname
+     * @returns {number}
+     *
+     * @memberof Refspec
+     */
+    dstMatches(refname: string): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Refspec
+     */
+    force(): number;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Refspec
+     */
+    src(): string;
+    /**
+     *
+     *
+     * @param {string} refname
+     * @returns {number}
+     *
+     * @memberof Refspec
+     */
+    srcMatches(refname: string): number;
+}

types/nodegit/reference.d.ts

@@ -0,0 +1,383 @@
+import { Repository } from './repository';
+import { Oid } from './oid';
+import { Object } from './object';
+
+export namespace Reference {
+    const enum TYPE {
+        INVALID = 0,
+        OID = 1,
+        SYMBOLIC = 2,
+        LISTALL = 3
+    }
+
+    const enum NORMALIZE {
+        REF_FORMAT_NORMAL = 0,
+        REF_FORMAT_ALLOW_ONELEVEL = 1,
+        REF_FORMAT_REFSPEC_PATTERN = 2,
+        REF_FORMAT_REFSPEC_SHORTHAND = 4
+    }
+}
+
+export class Reference {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @param {Oid} id
+     * @param {number} force
+     * @param {string} logMessage
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Reference
+     */
+    static create(repo: Repository, name: string, id: Oid, force: number, logMessage: string): Promise<Reference>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @param {Oid} id
+     * @param {number} force
+     * @param {Oid} currentId
+     * @param {string} logMessage
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Reference
+     */
+    static createMatching(repo: Repository, name: string, id: Oid, force: number, currentId: Oid, logMessage: string): Promise<Reference>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {(string | Reference)} id
+     * @param {Function} callback
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Reference
+     */
+    static dwim(repo: Repository, id: string | Reference, callback: Function): Promise<Reference>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} refname
+     * @returns {number}
+     *
+     * @memberof Reference
+     */
+    static ensureLog(repo: Repository, refname: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} refname
+     * @returns {number}
+     *
+     * @memberof Reference
+     */
+    static hasLog(repo: Repository, refname: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {string} refname
+     * @returns {number}
+     *
+     * @memberof Reference
+     */
+    static isValidName(refname: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @returns {Promise<any[]>}
+     *
+     * @memberof Reference
+     */
+    static list(repo: Repository): Promise<any[]>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {(string | Reference)} id
+     * @param {Function} callback
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Reference
+     */
+    static lookup(repo: Repository, id: string | Reference, callback: Function): Promise<Reference>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Reference
+     */
+    static nameToId(repo: Repository, name: string): Promise<Oid>;
+    /**
+     *
+     *
+     * @static
+     * @param {string} bufferOut
+     * @param {number} bufferSize
+     * @param {string} name
+     * @param {number} flags
+     * @returns {number}
+     *
+     * @memberof Reference
+     */
+    static normalizeName(bufferOut: string, bufferSize: number, name: string, flags: number): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @returns {number}
+     *
+     * @memberof Reference
+     */
+    static remove(repo: Repository, name: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @param {string} target
+     * @param {number} force
+     * @param {string} logMessage
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Reference
+     */
+    static symbolicCreate(repo: Repository, name: string, target: string, force: number, logMessage: string): Promise<Reference>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @param {string} target
+     * @param {number} force
+     * @param {string} currentValue
+     * @param {string} logMessage
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Reference
+     */
+    static symbolicCreateMatching(repo: Repository, name: string, target: string, force: number, currentValue: string, logMessage: string): Promise<Reference>;
+
+    /**
+     *
+     *
+     * @param {Reference} ref2
+     * @returns {number}
+     *
+     * @memberof Reference
+     */
+    cmp(ref2: Reference): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Reference
+     */
+    delete(): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Reference
+     */
+    isBranch(): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Reference
+     */
+    isNote(): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Reference
+     */
+    isRemote(): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Reference
+     */
+    isTag(): number;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Reference
+     */
+    name(): string;
+    /**
+     *
+     *
+     * @returns {Repository}
+     *
+     * @memberof Reference
+     */
+    owner(): Repository;
+    /**
+     *
+     *
+     * @param {number} type
+     * @returns {Promise<Object>}
+     *
+     * @memberof Reference
+     */
+    peel(type: number): Promise<Object>;
+    /**
+     *
+     *
+     * @param {string} newName
+     * @param {number} force
+     * @param {string} logMessage
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Reference
+     */
+    rename(newName: string, force: number, logMessage: string): Promise<Reference>;
+    /**
+     *
+     *
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Reference
+     */
+    resolve(): Promise<Reference>;
+    /**
+     *
+     *
+     * @param {Oid} id
+     * @param {string} logMessage
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Reference
+     */
+    setTarget(id: Oid, logMessage: string): Promise<Reference>;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Reference
+     */
+    shorthand(): string;
+    /**
+     *
+     *
+     * @param {string} target
+     * @param {string} logMessage
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Reference
+     */
+    symbolicSetTarget(target: string, logMessage: string): Promise<Reference>;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Reference
+     */
+    symbolicTarget(): string;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Reference
+     */
+    target(): Oid;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Reference
+     */
+    targetPeel(): Oid;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Reference
+     */
+    type(): number;
+    /**
+     *
+     *
+     * @returns {boolean}
+     *
+     * @memberof Reference
+     */
+    isValid(): boolean;
+    /**
+     *
+     *
+     * @returns {boolean}
+     *
+     * @memberof Reference
+     */
+    isConcrete(): boolean;
+    /**
+     *
+     *
+     * @returns {boolean}
+     *
+     * @memberof Reference
+     */
+    isSymbolic(): boolean;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Reference
+     */
+    toString(): string;
+    /**
+     *
+     *
+     * @returns {boolean}
+     *
+     * @memberof Reference
+     */
+    isHead(): boolean;
+    /**
+     *
+     *
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Reference
+     */
+    dup(): Promise<Reference>;
+}

types/nodegit/remote-callbacks.d.ts

@@ -0,0 +1,44 @@
+export class RemoteCallbacks {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof RemoteCallbacks
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {Function}
+     * @memberof RemoteCallbacks
+     */
+    credentials?: Function;
+    /**
+     *
+     *
+     * @type {Function}
+     * @memberof RemoteCallbacks
+     */
+    certificateCheck?: Function;
+    /**
+     *
+     *
+     * @type {Function}
+     * @memberof RemoteCallbacks
+     */
+    transferProgress?: Function;
+    /**
+     *
+     *
+     * @type {Function}
+     * @memberof RemoteCallbacks
+     */
+    transport?: Function;
+    /**
+     *
+     *
+     * @type {undefined}
+     * @memberof RemoteCallbacks
+     */
+    payload?: undefined;
+}

types/nodegit/remote.d.ts

@@ -0,0 +1,390 @@
+import { Repository } from './repository';
+import { RemoteCallbacks } from './remote-callbacks';
+import { Strarray } from './str-array';
+import { FetchOptions } from './fetch-options';
+import { Buf } from './buf';
+import { Enums } from './enums';
+import { TransferProgress } from './transfer-progress';
+import { PushOptions } from './push-options';
+import { Refspec } from './ref-spec';
+
+export namespace Remote {
+    const enum AUTOTAG_OPTION {
+        DOWNLOAD_TAGS_UNSPECIFIED = 0,
+        DOWNLOAD_TAGS_AUTO = 1,
+        DOWNLOAD_TAGS_NONE = 2,
+        DOWNLOAD_TAGS_ALL = 3
+    }
+
+    const enum COMPLETION_TYPE {
+        COMPLETION_DOWNLOAD = 0,
+        COMPLETION_INDEXING = 1,
+        COMPLETION_ERROR = 2
+    }
+}
+
+export class Remote {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} remote
+     * @param {string} refspec
+     * @returns {number}
+     *
+     * @memberof Remote
+     */
+    static addFetch(repo: Repository, remote: string, refspec: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} remote
+     * @param {string} refspec
+     * @returns {number}
+     *
+     * @memberof Remote
+     */
+    static addPush(repo: Repository, remote: string, refspec: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @param {string} url
+     * @returns {Remote}
+     *
+     * @memberof Remote
+     */
+    static create(repo: Repository, name: string, url: string): Remote;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} url
+     * @returns {Promise<Remote>}
+     *
+     * @memberof Remote
+     */
+    static createAnonymous(repo: Repository, url: string): Promise<Remote>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @param {string} url
+     * @param {string} fetch
+     * @returns {Promise<Remote>}
+     *
+     * @memberof Remote
+     */
+    static createWithFetchspec(repo: Repository, name: string, url: string, fetch: string): Promise<Remote>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @returns {Promise<number>}
+     *
+     * @memberof Remote
+     */
+    static delete(repo: Repository, name: string): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {RemoteCallbacks} opts
+     * @param {number} version
+     * @returns {number}
+     *
+     * @memberof Remote
+     */
+    static initCallbacks(opts: RemoteCallbacks, version: number): number;
+    /**
+     *
+     *
+     * @static
+     * @param {string} remoteName
+     * @returns {number}
+     *
+     * @memberof Remote
+     */
+    static isValidName(remoteName: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @returns {Promise<any[]>}
+     *
+     * @memberof Remote
+     */
+    static list(repo: Repository): Promise<any[]>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {(string | Remote)} name
+     * @param {Function} callback
+     * @returns {Promise<Remote>}
+     *
+     * @memberof Remote
+     */
+    static lookup(repo: Repository, name: string | Remote, callback: Function): Promise<Remote>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} remote
+     * @param {number} value
+     * @returns {number}
+     *
+     * @memberof Remote
+     */
+    static setAutotag(repo: Repository, remote: string, value: number): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} remote
+     * @param {string} url
+     * @returns {number}
+     *
+     * @memberof Remote
+     */
+    static setPushurl(repo: Repository, remote: string, url: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} remote
+     * @param {string} url
+     * @returns {number}
+     *
+     * @memberof Remote
+     */
+    static setUrl(repo: Repository, remote: string, url: string): number;
+
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Remote
+     */
+    autotag(): number;
+    /**
+     *
+     *
+     * @param {Enums.DIRECTION} direction
+     * @param {RemoteCallbacks} callbacks
+     * @param {Function} callback
+     * @returns {Promise<number>}
+     *
+     * @memberof Remote
+     */
+    connect(direction: Enums.DIRECTION, callbacks: RemoteCallbacks, callback: Function): Promise<number>;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Remote
+     */
+    connected(): number;
+    /**
+     *
+     *
+     * @returns {Promise<Buf>}
+     *
+     * @memberof Remote
+     */
+    defaultBranch(): Promise<Buf>;
+    /**
+     *
+     *
+     * @returns {Promise<void>}
+     *
+     * @memberof Remote
+     */
+    disconnect(): Promise<void>;
+    /**
+     *
+     *
+     * @param {any[]} refSpecs
+     * @param {FetchOptions} opts
+     * @param {Function} callback
+     * @returns {Promise<number>}
+     *
+     * @memberof Remote
+     */
+    download(refSpecs: any[], opts: FetchOptions, callback: Function): Promise<number>;
+    dup(): Promise<Remote>;
+    /**
+     *
+     *
+     * @param {any[]} refSpecs
+     * @param {FetchOptions} opts
+     * @param {string} message
+     * @param {Function} callback
+     * @returns {Promise<number>}
+     *
+     * @memberof Remote
+     */
+    fetch(refSpecs: any[], opts: FetchOptions, message: string, callback: Function): Promise<number>;
+    /**
+     *
+     *
+     *
+     * @memberof Remote
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {Promise<any[]>}
+     *
+     * @memberof Remote
+     */
+    getFetchRefspecs(): Promise<any[]>;
+    /**
+     *
+     *
+     * @returns {Promise<any[]>}
+     *
+     * @memberof Remote
+     */
+    getPushRefspecs(): Promise<any[]>;
+    /**
+     *
+     *
+     * @param {number} n
+     * @returns {Refspec}
+     *
+     * @memberof Remote
+     */
+    getRefspec(n: number): Refspec;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Remote
+     */
+    name(): string;
+    /**
+     *
+     *
+     * @returns {Repository}
+     *
+     * @memberof Remote
+     */
+    owner(): Repository;
+    /**
+     *
+     *
+     * @param {RemoteCallbacks} callbacks
+     * @returns {number}
+     *
+     * @memberof Remote
+     */
+    prune(callbacks: RemoteCallbacks): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Remote
+     */
+    pruneRefs(): number;
+    /**
+     *
+     *
+     * @param {any[]} refSpecs
+     * @param {PushOptions} options
+     * @param {Function} callback
+     * @returns {Promise<number>}
+     *
+     * @memberof Remote
+     */
+    push(refSpecs: any[], options: PushOptions, callback: Function): Promise<number>;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Remote
+     */
+    pushurl(): string;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Remote
+     */
+    refspecCount(): number;
+    /**
+     *
+     *
+     * @returns {TransferProgress}
+     *
+     * @memberof Remote
+     */
+    stats(): TransferProgress;
+    /**
+     *
+     *
+     *
+     * @memberof Remote
+     */
+    stop(): void;
+    /**
+     *
+     *
+     * @param {RemoteCallbacks} callbacks
+     * @param {number} updateFetchhead
+     * @param {number} downloadTags
+     * @param {string} reflogMessage
+     * @returns {number}
+     *
+     * @memberof Remote
+     */
+    updateTips(callbacks: RemoteCallbacks, updateFetchhead: number, downloadTags: number, reflogMessage: string): number;
+    /**
+     *
+     *
+     * @param {Strarray} refspecs
+     * @param {PushOptions} opts
+     * @returns {number}
+     *
+     * @memberof Remote
+     */
+    upload(refspecs: Strarray, opts: PushOptions): number;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Remote
+     */
+    url(): string;
+    /**
+     * Lists advertised references from a remote. You must connect to the remote before using referenceList.
+     *
+     * @returns {Promise<any[]>}
+     *
+     * @memberof Remote
+     */
+    referenceList(): Promise<any[]>;
+}

types/nodegit/repository.d.ts

@@ -0,0 +1,786 @@
+import { Oid } from './oid';
+import { Buf } from './buf';
+import { Reference } from './reference';
+import { Odb } from './odb';
+import { Object } from './object';
+import { Index } from './index_';
+import { Commit } from './commit';
+import { Blob } from './blob';
+import { Tree } from './tree';
+import { Signature } from './signature';
+import { AnnotatedCommit } from './annotated-commit';
+import { FetchOptions } from './fetch-options';
+import { CheckoutOptions } from './checkout-options';
+import { Remote } from './remote';
+import { Tag } from './tag';
+import { Config } from './config';
+import { Merge } from './merge';
+import { MergeOptions } from './merge-options';
+import { Refdb } from './ref-db';
+import { Revwalk } from './rev-walk';
+
+export interface RepositoryInitOptions {
+    description: string;
+    flags: number;
+    initialHead: string;
+    mode: number;
+    originUrl: string;
+    templatePath: string;
+    version: number;
+    workdirPath: string;
+}
+
+export class Repository {
+    /**
+     * Creates a branch with the passed in name pointing to the commit
+     *
+     * @static
+     * @param {string} startPath
+     * @param {number} acrossFs
+     * @param {string} ceilingDirs
+     * @returns {Promise<string>}
+     *
+     * @memberof Repository
+     */
+    static discover(startPath: string, acrossFs: number, ceilingDirs: string): Promise<Buf>;
+    /**
+     *
+     *
+     * @static
+     * @param {string} path
+     * @param {boolean} [isBare]
+     * @returns {Promise<Repository>}
+     *
+     * @memberof Repository
+     */
+    static init(path: string, isBare?: boolean): Promise<Repository>;
+    /**
+     *
+     *
+     * @static
+     * @param {string} repoPath
+     * @param {RepositoryInitOptions} [options]
+     * @returns {Promise<Repository>}
+     *
+     * @memberof Repository
+     */
+    static initExt(repoPath: string, options?: RepositoryInitOptions): Promise<Repository>;
+    /**
+     *
+     *
+     * @static
+     * @param {string} path
+     * @returns {Promise<Repository>}
+     *
+     * @memberof Repository
+     */
+    static open(path: string): Promise<Repository>;
+    /**
+     *
+     *
+     * @static
+     * @param {string} barePath
+     * @returns {Promise<Repository>}
+     *
+     * @memberof Repository
+     */
+    static openBare(barePath: string): Promise<Repository>;
+    /**
+     *
+     *
+     * @static
+     * @param {string} path
+     * @param {number} [flags]
+     * @param {string} [ceilingDirs]
+     * @returns {Promise<Repository>}
+     *
+     * @memberof Repository
+     */
+    static openExt(path: string, flags?: number, ceilingDirs?: string): Promise<Repository>;
+    /**
+     *
+     *
+     * @static
+     * @param {Odb} odb
+     * @returns {Promise<Repository>}
+     *
+     * @memberof Repository
+     */
+    static wrapOdb(odb: Odb): Promise<Repository>;
+
+    /**
+     *
+     *
+     *
+     * @memberof Repository
+     */
+    cleanup(): void;
+    /**
+     *
+     *
+     * @returns {Promise<Config>}
+     *
+     * @memberof Repository
+     */
+    config(): Promise<Config>;
+    /**
+     *
+     *
+     * @returns {Promise<Config>}
+     *
+     * @memberof Repository
+     */
+    configSnapshot(): Promise<Config>;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Repository
+     */
+    detachHead(): number;
+    /**
+     *
+     *
+     * @param {Function} callback
+     * @returns {Promise<any>}
+     *
+     * @memberof Repository
+     */
+    fetchheadForeach(callback: Function): Promise<any>;
+    /**
+     *
+     *
+     *
+     * @memberof Repository
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Repository
+     */
+    getNamespace(): string;
+    /**
+     *
+     *
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Repository
+     */
+    head(): Promise<Reference>;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Repository
+     */
+    headDetached(): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Repository
+     */
+    headUnborn(): number;
+    /**
+     *
+     *
+     * @returns {Promise<Index>}
+     *
+     * @memberof Repository
+     */
+    index(): Promise<Index>;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Repository
+     */
+    isBare(): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Repository
+     */
+    isEmpty(): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Repository
+     */
+    isShallow(): number;
+    /**
+     *
+     *
+     * @param {Function} callback
+     * @returns {Promise<any>}
+     *
+     * @memberof Repository
+     */
+    mergeheadForeach(callback: Function): Promise<any>;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Repository
+     */
+    messageRemove(): number;
+    /**
+     *
+     *
+     * @returns {Promise<Odb>}
+     *
+     * @memberof Repository
+     */
+    odb(): Promise<Odb>;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Repository
+     */
+    path(): string;
+    /**
+     *
+     *
+     * @returns {Promise<Refdb>}
+     *
+     * @memberof Repository
+     */
+    refdb(): Promise<Refdb>;
+    /**
+     *
+     *
+     * @param {string} refname
+     * @returns {Promise<number>}
+     *
+     * @memberof Repository
+     */
+    setHead(refname: string): Promise<number>;
+    /**
+     *
+     *
+     * @param {Oid} commitish
+     * @returns {number}
+     *
+     * @memberof Repository
+     */
+    setHeadDetached(commitish: Oid): number;
+    /**
+     *
+     *
+     * @param {AnnotatedCommit} commitish
+     * @returns {number}
+     *
+     * @memberof Repository
+     */
+    setHeadDetachedFromAnnotated(commitish: AnnotatedCommit): number;
+    /**
+     *
+     *
+     * @param {string} name
+     * @param {string} email
+     * @returns {number}
+     *
+     * @memberof Repository
+     */
+    setIdent(name: string, email: string): number;
+    /**
+     *
+     *
+     * @param {string} nmspace
+     * @returns {number}
+     *
+     * @memberof Repository
+     */
+    setNamespace(nmspace: string): number;
+    /**
+     *
+     *
+     * @param {string} workdir
+     * @param {number} updateGitLink
+     * @returns {number}
+     *
+     * @memberof Repository
+     */
+    setWorkdir(workdir: string, updateGitLink: number): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Repository
+     */
+    state(): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Repository
+     */
+    stateCleanup(): number;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Repository
+     */
+    workdir(): string;
+    /**
+     * Creates a branch with the passed in name pointing to the commit
+     *
+     * @param {string} name
+     * @param {(Commit | string | Oid)} commit
+     * @param {boolean} force
+     * @param {Signature} signature
+     * @param {string} logMessage
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Repository
+     */
+    createBranch(name: string, commit: Commit | string | Oid, force: boolean, signature: Signature, logMessage: string): Promise<Reference>;
+    /**
+     * Look up a refs's commit.
+     *
+     * @param {(string | Reference)} name
+     * @returns {Promise<Commit>}
+     *
+     * @memberof Repository
+     */
+    getReferenceCommit(name: string | Reference): Promise<Commit>;
+    /**
+     * Look up a branch. Alias for getReference
+     *
+     * @param {(string | Reference)} name
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Repository
+     */
+    getBranch(name: string | Reference): Promise<Reference>;
+    /**
+     * Look up a branch's most recent commit. Alias to getReferenceCommit
+     *
+     * @param {(string | Reference)} name
+     * @returns {Promise<Commit>}
+     *
+     * @memberof Repository
+     */
+    getBranchCommit(name: string | Reference): Promise<Commit>;
+    /**
+     * Gets the branch that HEAD currently points to Is an alias to head()
+     *
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Repository
+     */
+    getCurrentBranch(): Promise<Reference>;
+    /**
+     * Lookup the reference with the given name.
+     *
+     * @param {(string | Reference)} name
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Repository
+     */
+    getReference(name: string | Reference): Promise<Reference>;
+    /**
+     * Lookup references for a repository.
+     *
+     * @param {Reference.TYPE} type
+     * @returns {Promise<Reference[]>}
+     *
+     * @memberof Repository
+     */
+    getReferences(type: Reference.TYPE): Promise<Reference[]>;
+    /**
+     * Lookup reference names for a repository.
+     *
+     * @param {Reference.TYPE} type
+     * @returns {Promise<string[]>}
+     *
+     * @memberof Repository
+     */
+    getReferenceNames(type: Reference.TYPE): Promise<string[]>;
+    /**
+     *
+     *
+     * @param {(string | Oid)} string
+     * @returns {Promise<Commit>}
+     *
+     * @memberof Repository
+     */
+    getCommit(string: string | Oid): Promise<Commit>;
+    /**
+     * Retrieve the blob represented by the oid.
+     *
+     * @param {(string | Oid)} string
+     * @returns {Promise<Blob>}
+     *
+     * @memberof Repository
+     */
+    getBlob(string: string | Oid): Promise<Blob>;
+    /**
+     * Retrieve the tree represented by the oid.
+     *
+     * @param {(string | Oid)} string
+     * @returns {Promise<Tree>}
+     *
+     * @memberof Repository
+     */
+    getTree(string: string | Oid): Promise<Tree>;
+    /**
+     *
+     *
+     * @param {(string | Oid)} string
+     * @param {string} name
+     * @param {string} message
+     * @returns {Promise<Tag>}
+     *
+     * @memberof Repository
+     */
+    createTag(string: string | Oid, name: string, message: string): Promise<Tag>;
+    /**
+     * Creates a new lightweight tag
+     *
+     * @param {(string | Oid)} string
+     * @param {string} name
+     * @returns {Promise<Reference>}
+     *
+     * @memberof Repository
+     */
+    createLightweightTag(string: string | Oid, name: string): Promise<Reference>;
+    /**
+     * Retrieve the tag represented by the oid.
+     *
+     * @param {(string | Oid)} string
+     * @returns {Promise<Tag>}
+     *
+     * @memberof Repository
+     */
+    getTag(string: string | Oid): Promise<Tag>;
+    /**
+     * Retrieve the tag represented by the tag name.
+     *
+     * @param {string} Short
+     * @returns {Promise<Tag>}
+     *
+     * @memberof Repository
+     */
+    getTagByName(Short: string): Promise<Tag>;
+    /**
+     * Deletes a tag from a repository by the tag name.
+     *
+     * @param {string} Short
+     * @returns {Promise<any>}
+     *
+     * @memberof Repository
+     */
+    deleteTagByName(Short: string): Promise<any>;
+    /**
+     * Instantiate a new revision walker for browsing the Repository"s history. See also Commit.prototype.history()
+     *
+     * @param {(string | Oid)} string
+     * @returns {Revwalk}
+     *
+     * @memberof Repository
+     */
+    createRevWalk(string: string | Oid): Revwalk;
+    /**
+     * Retrieve the master branch commit.
+     *
+     * @returns {Promise<Commit>}
+     *
+     * @memberof Repository
+     */
+    getMasterCommit(): Promise<Commit>;
+    /**
+     * Retrieve the commit that HEAD is currently pointing to
+     *
+     * @returns {Promise<Commit>}
+     *
+     * @memberof Repository
+     */
+    getHeadCommit(): Promise<Commit>;
+    /**
+     *
+     *
+     * @param {string} updateRef
+     * @param {Signature} author
+     * @param {Signature} committer
+     * @param {string} message
+     * @param {(Tree | Oid | string)} Tree
+     * @param {any[]} parents
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Repository
+     */
+    createCommit(updateRef: string, author: Signature, committer: Signature, message: string, Tree: Tree | Oid | string, parents: any[]): Promise<Oid>;
+    /**
+     * Creates a new commit on HEAD from the list of passed in files
+     *
+     * @param {any[]} filesToAdd
+     * @param {Signature} author
+     * @param {Signature} committer
+     * @param {string} message
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Repository
+     */
+    createCommitOnHead(filesToAdd: any[], author: Signature, committer: Signature, message: string): Promise<Oid>;
+    /**
+     * Create a blob from a buffer
+     *
+     * @param {Buffer} buffer
+     * @returns {Oid}
+     *
+     * @memberof Repository
+     */
+    createBlobFromBuffer(buffer: Buffer): Oid;
+    /**
+     *
+     *
+     * @param {Tree} tree
+     * @returns {*}
+     *
+     * @memberof Repository
+     */
+    treeBuilder(tree: Tree): any;
+    /**
+     * Gets the default signature for the default user and now timestamp
+     *
+     * @returns {Signature}
+     *
+     * @memberof Repository
+     */
+    defaultSignature(): Signature;
+    /**
+     * Lists out the remotes in the given repository.
+     *
+     * @param {Function} Optional
+     * @returns {Promise<Object>}
+     *
+     * @memberof Repository
+     */
+    getRemotes(Optional: Function): Promise<Object>;
+    /**
+     * Gets a remote from the repo
+     *
+     * @param {(string | Remote)} remote
+     * @param {Function} callback
+     * @returns {Promise<Remote>}
+     *
+     * @memberof Repository
+     */
+    getRemote(remote: string | Remote, callback: Function): Promise<Remote>;
+    /**
+     * Fetches from a remote
+     *
+     * @param {(string | Remote)} remote
+     * @param {(Object | FetchOptions)} fetchOptions
+     * @returns {Promise<any>}
+     *
+     * @memberof Repository
+     */
+    fetch(remote: string | Remote, fetchOptions: Object | FetchOptions): Promise<void>;
+    /**
+     * Fetches from all remotes. This is done in series due to deadlocking issues with fetching from many remotes that can happen.
+     *
+     * @param {(Object | FetchOptions)} fetchOptions
+     * @param {Function} callback
+     * @returns {Promise<void>}
+     *
+     * @memberof Repository
+     */
+    fetchAll(fetchOptions: Object | FetchOptions, callback: Function): Promise<void>;
+    /**
+     *
+     *
+     * @param {(string | Reference)} to
+     * @param {(string | Reference)} from
+     * @param {Signature} signature
+     * @param {Merge.PREFERENCE} mergePreference
+     * @param {MergeOptions} mergeOptions
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Repository
+     */
+    mergeBranches(to: string | Reference, from: string | Reference, signature: Signature, mergePreference: Merge.PREFERENCE, mergeOptions: MergeOptions): Promise<Oid>;
+    /**
+     * Rebases a branch onto another branch
+     *
+     * @param {string} branch
+     * @param {string} upstream
+     * @param {string} onto
+     * @param {Signature} signature
+     * @param {Function} beforeNextFn
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Repository
+     */
+    rebaseBranches(branch: string, upstream: string, onto: string, signature: Signature, beforeNextFn: Function): Promise<Oid>;
+    /**
+     *
+     *
+     * @param {Signature} signature
+     * @param {Function} beforeNextFn
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Repository
+     */
+    continueRebase(signature: Signature, beforeNextFn: Function): Promise<Oid>;
+    /**
+     * Get the status of a repo to it's working directory
+     *
+     * @param {*} opts
+     * @returns {Promise<any[]>}
+     *
+     * @memberof Repository
+     */
+    getStatus(opts: any): Promise<any[]>;
+    /**
+     * Get extended statuses of a repo to it's working directory. Status entries have status, headToIndex delta, and indexToWorkdir deltas
+     *
+     * @param {*} opts
+     * @returns {Promise<any[]>}
+     *
+     * @memberof Repository
+     */
+    getStatusExt(opts: any): Promise<any[]>;
+    /**
+     * Get the names of the submodules in the repository.
+     *
+     * @returns {Promise<string[]>}
+     *
+     * @memberof Repository
+     */
+    getSubmoduleNames(): Promise<string[]>;
+    /**
+     * This will set the HEAD to point to the reference and then attempt to update the index and working tree to match the content of the latest commit on that reference
+     *
+     * @param {Reference} reference
+     * @param {(Object | CheckoutOptions)} opts
+     * @returns {Promise<any>}
+     *
+     * @memberof Repository
+     */
+    checkoutRef(reference: Reference, opts: Object | CheckoutOptions): Promise<any>;
+    /**
+     * This will set the HEAD to point to the local branch and then attempt to update the index and working tree to match the content of the latest commit on that branch
+     *
+     * @param {(string | Reference)} branch
+     * @param {(Object | CheckoutOptions)} opts
+     * @returns {Promise<any>}
+     *
+     * @memberof Repository
+     */
+    checkoutBranch(branch: string | Reference, opts: Object | CheckoutOptions): Promise<any>;
+    /**
+     * Stages or unstages line selection of a specified file
+     *
+     * @param {(string | any[])} filePath
+     * @param {boolean} stageNew
+     * @returns {Promise<number>}
+     *
+     * @memberof Repository
+     */
+    stageFilemode(filePath: string | any[], stageNew: boolean): Promise<number>;
+    /**
+     * Stages or unstages line selection of a specified file
+     *
+     * @param {string} filePath
+     * @param {any[]} newLines
+     * @param {boolean} isStaged
+     * @returns {Promise<number>}
+     *
+     * @memberof Repository
+     */
+    stageLines(filePath: string, newLines: any[], isStaged: boolean): Promise<number>;
+    /**
+     * Returns true if the repository is in the default NONE state.
+     *
+     * @returns {boolean}
+     *
+     * @memberof Repository
+     */
+    isDefaultState(): boolean;
+    /**
+     * Returns true if the repository is in the APPLY_MAILBOX or APPLY_MAILBOX_OR_REBASE state.
+     *
+     * @returns {boolean}
+     *
+     * @memberof Repository
+     */
+    isApplyingMailbox(): boolean;
+    /**
+     * Returns true if the repository is in the BISECT state.
+     *
+     * @returns {boolean}
+     *
+     * @memberof Repository
+     */
+    isBisecting(): boolean;
+    /**
+     * Returns true if the repository is in the CHERRYPICK state.
+     *
+     * @returns {boolean}
+     *
+     * @memberof Repository
+     */
+    isCherrypicking(): boolean;
+    /**
+     * Returns true if the repository is in the MERGE state.
+     *
+     * @returns {boolean}
+     *
+     * @memberof Repository
+     */
+    isMerging(): boolean;
+    /**
+     * Returns true if the repository is in the REBASE, REBASE_INTERACTIVE, or REBASE_MERGE state.
+     *
+     * @returns {boolean}
+     *
+     * @memberof Repository
+     */
+    isRebasing(): boolean;
+    /**
+     * Returns true if the repository is in the REVERT state.
+     *
+     * @returns {boolean}
+     *
+     * @memberof Repository
+     */
+    isReverting(): boolean;
+    /**
+     * Discard line selection of a specified file. Assumes selected lines are unstaged.
+     *
+     * @param {string} filePath
+     * @param {any[]} selectedLines
+     * @returns {Promise<number>}
+     *
+     * @memberof Repository
+     */
+    discardLines(filePath: string, selectedLines: any[]): Promise<number>;
+    /**
+     * Grabs a fresh copy of the index from the repository. Invalidates all previously grabbed indexes
+     *
+     * @returns {Promise<Index>}
+     *
+     * @memberof Repository
+     */
+    refreshIndex(): Promise<Index>;
+}

types/nodegit/reset.d.ts

@@ -0,0 +1,56 @@
+import { AnnotatedCommit } from './annotated-commit';
+import { Repository } from './repository';
+import { Object } from './object';
+import { Strarray } from './str-array';
+import { CheckoutOptions } from './checkout-options';
+
+export namespace Reset {
+    const enum TYPE {
+        SOFT = 1,
+        MIXED = 2,
+        HARD = 3
+    }
+}
+
+export class Reset {
+    /**
+     * Look up a refs's commit.
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Object} target
+     * @param {number} resetType
+     * @param {CheckoutOptions} checkoutOpts
+     * @returns {Promise<number>}
+     *
+     * @memberof Reset
+     */
+    static reset(repo: Repository, target: Object, resetType: number, checkoutOpts: CheckoutOptions): Promise<number>;
+    /**
+     * Look up a refs's commit.
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Object} target
+     * @param {Strarray} pathspecs
+     * @returns {Promise<number>}
+     *
+     * @memberof Reset
+     */
+    static default(repo: Repository, target: Object, pathspecs: Strarray): Promise<number>;
+    /**
+     * Sets the current head to the specified commit oid and optionally resets the index and working tree to match.
+     * This behaves like reset but takes an annotated commit, which lets you specify which extended sha syntax string was specified by a user, allowing for more exact reflog messages.
+     * See the documentation for reset.
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {AnnotatedCommit} commit
+     * @param {number} resetType
+     * @param {CheckoutOptions} checkoutOpts
+     * @returns {number}
+     *
+     * @memberof Reset
+     */
+    static fromAnnotated(repo: Repository, commit: AnnotatedCommit, resetType: number, checkoutOpts: CheckoutOptions): number;
+}

types/nodegit/rev-parse.d.ts

@@ -0,0 +1,38 @@
+import { Object } from './object';
+import { Repository } from './repository';
+import { Reference } from './reference';
+
+export namespace Revparse {
+    const enum MODE {
+        SINGLE = 1,
+        RANGE = 2,
+        MERGE_BASE = 4
+    }
+}
+
+export class Revparse {
+    /**
+     *
+     *
+     * @static
+     * @param {Object} objectOut
+     * @param {Reference} referenceOut
+     * @param {Repository} repo
+     * @param {string} spec
+     * @returns {number}
+     *
+     * @memberof Revparse
+     */
+    static ext(objectOut: Object, referenceOut: Reference, repo: Repository, spec: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} spec
+     * @returns {Promise<Object>}
+     *
+     * @memberof Revparse
+     */
+    static single(repo: Repository, spec: string): Promise<Object>;
+}

types/nodegit/rev-walk.d.ts

@@ -0,0 +1,190 @@
+import { Repository } from './repository';
+import { Oid } from './oid';
+import { Commit } from './commit';
+
+export namespace Revwalk {
+    const enum SORT {
+        NONE = 0,
+        TOPOLOGICAL = 1,
+        TIME = 2,
+        REVERSE = 4
+    }
+}
+
+export class Revwalk {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @returns {Revwalk}
+     *
+     * @memberof Revwalk
+     */
+    static create(repo: Repository): Revwalk;
+
+    /**
+     *
+     *
+     * @param {Oid} commitId
+     * @returns {number}
+     *
+     * @memberof Revwalk
+     */
+    hide(commitId: Oid): number;
+    /**
+     *
+     *
+     * @param {string} glob
+     * @returns {number}
+     *
+     * @memberof Revwalk
+     */
+    hideGlob(glob: string): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Revwalk
+     */
+    hideHead(): number;
+    /**
+     *
+     *
+     * @param {string} refname
+     * @returns {number}
+     *
+     * @memberof Revwalk
+     */
+    hideRef(refname: string): number;
+    /**
+     *
+     *
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Revwalk
+     */
+    next(): Promise<Oid>;
+    /**
+     *
+     *
+     * @param {Oid} id
+     * @returns {number}
+     *
+     * @memberof Revwalk
+     */
+    push(id: Oid): number;
+    /**
+     *
+     *
+     * @param {string} glob
+     * @returns {number}
+     *
+     * @memberof Revwalk
+     */
+    pushGlob(glob: string): number;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Revwalk
+     */
+    pushHead(): number;
+    /**
+     *
+     *
+     * @param {string} range
+     * @returns {number}
+     *
+     * @memberof Revwalk
+     */
+    pushRange(range: string): number;
+    /**
+     *
+     *
+     * @param {string} refname
+     * @returns {number}
+     *
+     * @memberof Revwalk
+     */
+    pushRef(refname: string): number;
+    /**
+     *
+     *
+     * @returns {Repository}
+     *
+     * @memberof Revwalk
+     */
+    repository(): Repository;
+    /**
+     *
+     *
+     *
+     * @memberof Revwalk
+     */
+    reset(): void;
+    /**
+     *
+     *
+     *
+     * @memberof Revwalk
+     */
+    simplifyFirstParent(): void;
+    /**
+     * Set the sort order for the revwalk. This function takes variable arguments like revwalk.sorting(NodeGit.RevWalk.Topological, NodeGit.RevWalk.Reverse).
+     *
+     * @param {number} sort
+     *
+     * @memberof Revwalk
+     */
+    sorting(sort: number): void;
+    /**
+     *
+     *
+     * @param {number} maxCount
+     * @returns {Promise<any>}
+     *
+     * @memberof Revwalk
+     */
+    fastWalk(maxCount: number): Promise<any>;
+    /**
+     *
+     *
+     * @param {string} filePath
+     * @param {number} maxCount
+     * @returns {Promise<any[]>}
+     *
+     * @memberof Revwalk
+     */
+    fileHistoryWalk(filePath: string, maxCount: number): Promise<any[]>;
+    /**
+     * Walk the history from the given oid. The callback is invoked for each commit; When the walk is over, the callback is invoked with (null, null).
+     *
+     * @param {Oid} oid
+     * @param {Function} callback
+     * @returns {Commit}
+     *
+     * @memberof Revwalk
+     */
+    walk(oid: Oid, callback: Function): Commit;
+    /**
+     * Walk the history grabbing commits until the checkFn called with the current commit returns false.
+     *
+     * @param {Function} checkFn
+     * @returns {Promise<any[]>}
+     *
+     * @memberof Revwalk
+     */
+    getCommitsUntil(checkFn: Function): Promise<any[]>;
+    /**
+     *
+     *
+     * @param {number} count
+     * @returns {Promise<Commit[]>}
+     *
+     * @memberof Revwalk
+     */
+    getCommits(count: number): Promise<Commit[]>;
+}

types/nodegit/revert.d.ts

@@ -0,0 +1,41 @@
+import { MergeOptions } from './merge-options';
+import { CheckoutOptions } from './checkout-options';
+import { Repository } from './repository';
+import { Commit } from './commit';
+import { Index } from './index';
+
+export interface RevertOptions {
+    version: number;
+    mainline: number;
+    mergeOpts: MergeOptions;
+    checkoutOpts: CheckoutOptions;
+}
+
+export class Revert {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Commit} commit
+     * @param {RevertOptions} givenOpts
+     * @returns {Promise<number>}
+     *
+     * @memberof Revert
+     */
+    static revert(repo: Repository, commit: Commit, givenOpts: RevertOptions): Promise<number>;
+    /**
+     * Reverts the given commit against the given "our" commit, producing an index that reflects the result of the revert.
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Commit} revertCommit
+     * @param {Commit} ourCommit
+     * @param {number} mainline
+     * @param {MergeOptions} mergeOptions
+     * @returns {Promise<Index>}
+     *
+     * @memberof Revert
+     */
+    static commit(repo: Repository, revertCommit: Commit, ourCommit: Commit, mainline: number, mergeOptions: MergeOptions): Promise<Index>;
+}

types/nodegit/signature.d.ts

@@ -0,0 +1,94 @@
+import { Repository } from './repository';
+import { Time } from './time';
+
+export class Signature {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @returns {Signature}
+     *
+     * @memberof Signature
+     */
+    static default(repo: Repository): Signature;
+    /**
+     *
+     *
+     * @static
+     * @param {string} name
+     * @param {string} email
+     * @param {number} time
+     * @param {number} offset
+     * @returns {Signature}
+     *
+     * @memberof Signature
+     */
+    static create(name: string, email: string, time: number, offset: number): Signature;
+    /**
+     *
+     *
+     * @static
+     * @param {string} name
+     * @param {string} email
+     * @returns {Signature}
+     *
+     * @memberof Signature
+     */
+    static now(name: string, email: string): Signature;
+    /**
+     *
+     *
+     * @static
+     * @param {string} buf
+     * @returns {Promise<Signature>}
+     *
+     * @memberof Signature
+     */
+    static fromBuffer(buf: string): Promise<Signature>;
+
+    /**
+     *
+     *
+     * @returns {Promise<Signature>}
+     *
+     * @memberof Signature
+     */
+    dup(): Promise<Signature>;
+    /**
+     *
+     *
+     *
+     * @memberof Signature
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Signature
+     */
+    toString(): string;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof Signature
+     */
+    name: string;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof Signature
+     */
+    email: string;
+    /**
+     *
+     *
+     * @type {Time}
+     * @memberof Signature
+     */
+    when: Time;
+}

types/nodegit/stash.d.ts

@@ -0,0 +1,141 @@
+import { Repository } from './repository';
+import { Signature } from './signature';
+import { Oid } from './oid';
+import { CheckoutOptions } from './checkout-options';
+
+export namespace Stash {
+    const enum APPLY_FLAGS {
+        APPLY_DEFAULT = 0,
+        APPLY_REINSTATE_INDEX = 1
+    }
+
+    const enum APPLY_PROGRESS {
+        NONE = 0,
+        LOADING_STASH = 1,
+        ANALYZE_INDEX = 2,
+        ANALYZE_MODIFIED = 3,
+        ANALYZE_UNTRACKED = 4,
+        CHECKOUT_UNTRACKED = 5,
+        CHECKOUT_MODIFIED = 6,
+        DONE = 7
+    }
+
+    const enum FLAGS {
+        DEFAULT = 0,
+        KEEP_INDEX = 1,
+        INCLUDE_UNTRACKED = 2,
+        INCLUDE_IGNORED = 4
+    }
+}
+
+export interface StashApplyOptions {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof StashApplyOptions
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof StashApplyOptions
+     */
+    flags?: number;
+    /**
+     *
+     *
+     * @type {CheckoutOptions}
+     * @memberof StashApplyOptions
+     */
+    checkoutOptions?: CheckoutOptions;
+    /**
+     *
+     *
+     * @type {Function}
+     * @memberof StashApplyOptions
+     */
+    progressCb?: Function;
+    /**
+     *
+     *
+     * @type {*}
+     * @memberof StashApplyOptions
+     */
+    progressPayload?: any;
+}
+
+export class Stash {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {number} index
+     * @param {StashApplyOptions} options
+     * @returns {Promise<number>}
+     *
+     * @memberof Stash
+     */
+    static apply(repo: Repository, index: number, options: StashApplyOptions): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {StashApplyOptions} opts
+     * @param {number} version
+     * @returns {number}
+     *
+     * @memberof Stash
+     */
+    static applyInitOptions(opts: StashApplyOptions, version: number): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {number} index
+     * @returns {Promise<number>}
+     *
+     * @memberof Stash
+     */
+    static drop(repo: Repository, index: number): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Function} callback
+     * @param {*} payload
+     * @returns {Promise<number>}
+     *
+     * @memberof Stash
+     */
+    static foreach(repo: Repository, callback: Function, payload: any): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {number} index
+     * @param {StashApplyOptions} options
+     * @returns {Promise<number>}
+     *
+     * @memberof Stash
+     */
+    static pop(repo: Repository, index: number, options: StashApplyOptions): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Signature} stasher
+     * @param {string} message
+     * @param {number} flags
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Stash
+     */
+    static save(repo: Repository, stasher: Signature, message: string, flags: number): Promise<Oid>;
+}

types/nodegit/status-entry.d.ts

@@ -0,0 +1,25 @@
+import { DiffDelta } from './diff-delta';
+
+export class StatusEntry {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof StatusEntry
+     */
+    status: number;
+    /**
+     *
+     *
+     * @type {DiffDelta}
+     * @memberof StatusEntry
+     */
+    headToIndex: DiffDelta;
+    /**
+     *
+     *
+     * @type {DiffDelta}
+     * @memberof StatusEntry
+     */
+    indexToWorkdir: DiffDelta;
+}

types/nodegit/status-list.d.ts

@@ -0,0 +1,41 @@
+import { Repository } from './repository';
+import { DiffPerfdata } from './diff-perf-data';
+import { StatusOptions } from './status-options';
+
+export class StatusList {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {StatusOptions} opts
+     * @returns {Promise<StatusList>}
+     *
+     * @memberof StatusList
+     */
+    static create(repo: Repository, opts: StatusOptions): Promise<StatusList>;
+
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof StatusList
+     */
+    entrycount(): number;
+    /**
+     *
+     *
+     *
+     * @memberof StatusList
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {Promise<DiffPerfdata>}
+     *
+     * @memberof StatusList
+     */
+    getPerfdata(): Promise<DiffPerfdata>;
+}

types/nodegit/status-options.d.ts

@@ -0,0 +1,32 @@
+import { Strarray } from './str-array';
+
+export interface StatusOptions {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof StatusOptions
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof StatusOptions
+     */
+    show?: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof StatusOptions
+     */
+    flags?: number;
+    /**
+     *
+     *
+     * @type {Strarray}
+     * @memberof StatusOptions
+     */
+    pathspec?: Strarray;
+}

types/nodegit/status.d.ts

@@ -0,0 +1,110 @@
+import { Repository } from './repository';
+import { StatusList } from './status-list';
+import { StatusEntry } from './status-entry';
+import { StatusOptions } from './status-options';
+
+export namespace Status {
+    const enum STATUS {
+        CURRENT = 0,
+        INDEX_NEW = 1,
+        INDEX_MODIFIED = 2,
+        INDEX_DELETED = 4,
+        INDEX_RENAMED = 8,
+        INDEX_TYPECHANGE = 16,
+        WT_NEW = 128,
+        WT_MODIFIED = 256,
+        WT_DELETED = 512,
+        WT_TYPECHANGE = 1024,
+        WT_RENAMED = 2048,
+        WT_UNREADABLE = 4096,
+        IGNORED = 16384,
+        CONFLICTED = 32768
+    }
+
+    const enum OPT {
+        INCLUDE_UNTRACKED = 1,
+        INCLUDE_IGNORED = 2,
+        INCLUDE_UNMODIFIED = 4,
+        EXCLUDE_SUBMODULES = 8,
+        RECURSE_UNTRACKED_DIRS = 16,
+        DISABLE_PATHSPEC_MATCH = 32,
+        RECURSE_IGNORED_DIRS = 64,
+        RENAMES_HEAD_TO_INDEX = 128,
+        RENAMES_INDEX_TO_WORKDIR = 256,
+        SORT_CASE_SENSITIVELY = 512,
+        SORT_CASE_INSENSITIVELY = 1024,
+        RENAMES_FROM_REWRITES = 2048,
+        NO_REFRESH = 4096,
+        UPDATE_INDEX = 8192,
+        INCLUDE_UNREADABLE = 16384,
+        INCLUDE_UNREADABLE_AS_UNTRACKED = 32768
+    }
+
+    const enum SHOW {
+        INDEX_AND_WORKDIR = 0,
+        INDEX_ONLY = 1,
+        WORKDIR_ONLY = 2
+    }
+}
+
+export class Status {
+    /**
+     *
+     *
+     * @static
+     * @param {StatusList} statuslist
+     * @param {number} idx
+     * @returns {StatusEntry}
+     *
+     * @memberof Status
+     */
+    static byIndex(statuslist: StatusList, idx: number): StatusEntry;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} path
+     * @returns {number}
+     *
+     * @memberof Status
+     */
+    static file(repo: Repository, path: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Function} callback
+     * @param {*} payload
+     * @returns {Promise<number>}
+     *
+     * @memberof Status
+     */
+    static foreach(repo: Repository, callback: Function, payload: any): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {StatusOptions} opts
+     * @param {Function} callback
+     * @param {*} payload
+     * @returns {Promise<number>}
+     *
+     * @memberof Status
+     */
+    static foreachExt(repo: Repository, opts: StatusOptions, callback: Function, payload: any): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {number} ignored
+     * @param {Repository} repo
+     * @param {string} path
+     * @returns {number}
+     *
+     * @memberof Status
+     */
+    static shouldIgnore(ignored: number, repo: Repository, path: string): number;
+}

types/nodegit/str-array.d.ts

@@ -0,0 +1,32 @@
+export class Strarray {
+    /**
+     *
+     *
+     * @param {Strarray} src
+     * @returns {number}
+     *
+     * @memberof Strarray
+     */
+    copy(src: Strarray): number;
+    /**
+     *
+     *
+     *
+     * @memberof Strarray
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @type {string[]}
+     * @memberof Strarray
+     */
+    strings: string[];
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof Strarray
+     */
+    count: number;
+}

types/nodegit/submodule-update-options.d.ts

@@ -0,0 +1,33 @@
+import { CheckoutOptions } from './checkout-options';
+import { FetchOptions } from './fetch-options';
+
+export interface SubmoduleUpdateOptions {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof SubmoduleUpdateOptions
+     */
+    version?: number;
+    /**
+     *
+     *
+     * @type {CheckoutOptions}
+     * @memberof SubmoduleUpdateOptions
+     */
+    checkoutOpts?: CheckoutOptions;
+    /**
+     *
+     *
+     * @type {FetchOptions}
+     * @memberof SubmoduleUpdateOptions
+     */
+    fetchOpts?: FetchOptions;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof SubmoduleUpdateOptions
+     */
+    cloneCheckoutStrategy?: number;
+}

types/nodegit/submodule.d.ts

@@ -0,0 +1,352 @@
+import { Repository } from './repository';
+import { Buf } from './buf';
+import { Oid } from './oid';
+import { SubmoduleUpdateOptions } from './submodule-update-options';
+
+export namespace Submodule {
+    const enum IGNORE {
+        UNSPECIFIED = -1,
+        NONE = 1,
+        UNTRACKED = 2,
+        DIRTY = 3,
+        ALL = 4
+    }
+
+    const enum RECURSE {
+        NO = 0,
+        YES = 1,
+        ONDEMAND = 2
+    }
+
+    const enum STATUS {
+        IN_HEAD = 1,
+        IN_INDEX = 2,
+        IN_CONFIG = 4,
+        IN_WD = 8,
+        INDEX_ADDED = 16,
+        INDEX_DELETED = 32,
+        INDEX_MODIFIED = 64,
+        WD_UNINITIALIZED = 128,
+        WD_ADDED = 256,
+        WD_DELETED = 512,
+        WD_MODIFIED = 1024,
+        WD_INDEX_MODIFIED = 2048,
+        WD_WD_MODIFIED = 4096,
+        WD_UNTRACKED = 8192
+    }
+
+    const enum UPDATE {
+        CHECKOUT = 1,
+        REBASE = 2,
+        MERGE = 3,
+        NONE = 4,
+        DEFAULT = 0
+    }
+}
+
+export class Submodule {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} url
+     * @param {string} path
+     * @param {number} useGitLink
+     * @returns {Promise<Submodule>}
+     *
+     * @memberof Submodule
+     */
+    static addSetup(repo: Repository, url: string, path: string, useGitLink: number): Promise<Submodule>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Function} callback
+     * @param {*} payload
+     * @returns {Promise<number>}
+     *
+     * @memberof Submodule
+     */
+    static foreach(repo: Repository, callback: Function, payload: any): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @returns {Promise<Submodule>}
+     *
+     * @memberof Submodule
+     */
+    static lookup(repo: Repository, name: string): Promise<Submodule>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} url
+     * @returns {Promise<Buf>}
+     *
+     * @memberof Submodule
+     */
+    static resolveUrl(repo: Repository, url: string): Promise<Buf>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @param {string} branch
+     * @returns {number}
+     *
+     * @memberof Submodule
+     */
+    static setBranch(repo: Repository, name: string, branch: string): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @param {number} fetchRecurseSubmodules
+     * @returns {number}
+     *
+     * @memberof Submodule
+     */
+    static setFetchRecurseSubmodules(repo: Repository, name: string, fetchRecurseSubmodules: number): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @param {number} ignore
+     * @returns {Promise<number>}
+     *
+     * @memberof Submodule
+     */
+    static setIgnore(repo: Repository, name: string, ignore: number): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @param {number} update
+     * @returns {Promise<number>}
+     *
+     * @memberof Submodule
+     */
+    static setUpdate(repo: Repository, name: string, update: number): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @param {string} url
+     * @returns {Promise<number>}
+     *
+     * @memberof Submodule
+     */
+    static setUrl(repo: Repository, name: string, url: string): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} name
+     * @param {number} ignore
+     * @returns {Promise<number>}
+     *
+     * @memberof Submodule
+     */
+    static status(repo: Repository, name: string, ignore: number): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {SubmoduleUpdateOptions} opts
+     * @param {number} version
+     * @returns {number}
+     *
+     * @memberof Submodule
+     */
+    static updateInitOptions(opts: SubmoduleUpdateOptions, version: number): number;
+
+    /**
+     *
+     *
+     * @returns {Promise<number>}
+     *
+     * @memberof Submodule
+     */
+    addFinalize(): Promise<number>;
+    /**
+     *
+     *
+     * @param {number} writeIndex
+     * @returns {Promise<number>}
+     *
+     * @memberof Submodule
+     */
+    addToIndex(writeIndex: number): Promise<number>;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Submodule
+     */
+    branch(): string;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Submodule
+     */
+    fetchRecurseSubmodules(): number;
+    /**
+     *
+     *
+     *
+     * @memberof Submodule
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Submodule
+     */
+    headId(): Oid;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Submodule
+     */
+    ignore(): number;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Submodule
+     */
+    indexId(): Oid;
+    /**
+     *
+     *
+     * @param {number} overwrite
+     * @returns {Promise<number>}
+     *
+     * @memberof Submodule
+     */
+    init(overwrite: number): Promise<number>;
+    /**
+     *
+     *
+     * @returns {Promise<number>}
+     *
+     * @memberof Submodule
+     */
+    location(): Promise<number>;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Submodule
+     */
+    name(): string;
+    /**
+     *
+     *
+     * @returns {Promise<Repository>}
+     *
+     * @memberof Submodule
+     */
+    open(): Promise<Repository>;
+    /**
+     *
+     *
+     * @returns {Repository}
+     *
+     * @memberof Submodule
+     */
+    owner(): Repository;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Submodule
+     */
+    path(): string;
+    /**
+     *
+     *
+     * @param {number} force
+     * @returns {number}
+     *
+     * @memberof Submodule
+     */
+    reload(force: number): number;
+    /**
+     *
+     *
+     * @param {number} useGitLink
+     * @returns {Promise<Repository>}
+     *
+     * @memberof Submodule
+     */
+    repoInit(useGitLink: number): Promise<Repository>;
+    /**
+     *
+     *
+     * @returns {Promise<number>}
+     *
+     * @memberof Submodule
+     */
+    sync(): Promise<number>;
+    /**
+     * Updates a submodule
+     *
+     * @param {number} init
+     * @param {SubmoduleUpdateOptions} options
+     * @returns {Promise<number>}
+     *
+     * @memberof Submodule
+     */
+    update(init: number, options: SubmoduleUpdateOptions): Promise<number>;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Submodule
+     */
+    updateStrategy(): number;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Submodule
+     */
+    url(): string;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Submodule
+     */
+    wdId(): Oid;
+}

types/nodegit/tag.d.ts

@@ -0,0 +1,195 @@
+import { Repository } from './repository';
+import { Oid } from './oid';
+import { Object } from './object';
+import { Signature } from './signature';
+import { Strarray } from './str-array';
+
+export class Tag {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} tagName
+     * @param {Object} target
+     * @param {Signature} tagger
+     * @param {string} message
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Tag
+     */
+    static annotationCreate(repo: Repository, tagName: string, target: Object, tagger: Signature, message: string): Promise<Oid>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} tagName
+     * @param {Object} target
+     * @param {Signature} tagger
+     * @param {string} message
+     * @param {number} force
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Tag
+     */
+    static create(repo: Repository, tagName: string, target: Object, tagger: Signature, message: string, force: number): Promise<Oid>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} tagName
+     * @param {Object} target
+     * @param {number} force
+     * @returns {Promise<Oid>}
+     *
+     * @memberof Tag
+     */
+    static createLightweight(repo: Repository, tagName: string, target: Object, force: number): Promise<Oid>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {string} tagName
+     * @returns {Promise<number>}
+     *
+     * @memberof Tag
+     */
+    static delete(repo: Repository, tagName: string): Promise<number>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @returns {Promise<any[]>}
+     *
+     * @memberof Tag
+     */
+    static list(repo: Repository): Promise<any[]>;
+    /**
+     *
+     *
+     * @static
+     * @param {Strarray} tagNames
+     * @param {string} pattern
+     * @param {Repository} repo
+     * @returns {number}
+     *
+     * @memberof Tag
+     */
+    static listMatch(tagNames: Strarray, pattern: string, repo: Repository): number;
+    /**
+     * Retrieves the tag pointed to by the oid
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {(string | Oid | Tag)} id
+     * @returns {Promise<Tag>}
+     *
+     * @memberof Tag
+     */
+    static lookup(repo: Repository, id: string | Oid | Tag): Promise<Tag>;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Oid} id
+     * @param {number} len
+     * @returns {Promise<Tag>}
+     *
+     * @memberof Tag
+     */
+    static lookupPrefix(repo: Repository, id: Oid, len: number): Promise<Tag>;
+
+    /**
+     *
+     *
+     * @returns {Promise<Tag>}
+     *
+     * @memberof Tag
+     */
+    dup(): Promise<Tag>;
+    /**
+     *
+     *
+     *
+     * @memberof Tag
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Tag
+     */
+    id(): Oid;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Tag
+     */
+    message(): string;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof Tag
+     */
+    name(): string;
+    /**
+     *
+     *
+     * @returns {Repository}
+     *
+     * @memberof Tag
+     */
+    owner(): Repository;
+    /**
+     *
+     *
+     * @param {Object} tagTargetOut
+     * @returns {number}
+     *
+     * @memberof Tag
+     */
+    peel(tagTargetOut: Object): number;
+    /**
+     *
+     *
+     * @returns {Signature}
+     *
+     * @memberof Tag
+     */
+    tagger(): Signature;
+    /**
+     *
+     *
+     * @returns {Object}
+     *
+     * @memberof Tag
+     */
+    target(): Object;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Tag
+     */
+    targetId(): Oid;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Tag
+     */
+    targetType(): number;
+}

types/nodegit/time.d.ts

@@ -0,0 +1,16 @@
+export class Time {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof Time
+     */
+    time: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof Time
+     */
+    offset: number;
+}

types/nodegit/transfer-progress.d.ts

@@ -0,0 +1,51 @@
+export class TransferProgress {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof TransferProgress
+     */
+    totalObjects: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof TransferProgress
+     */
+    indexedObjects: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof TransferProgress
+     */
+    receivedObjects: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof TransferProgress
+     */
+    localObjects: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof TransferProgress
+     */
+    totalDeltas: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof TransferProgress
+     */
+    indexedDeltas: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof TransferProgress
+     */
+    receivedBytes: number;
+}

types/nodegit/transport.d.ts

@@ -0,0 +1,53 @@
+import { Remote } from './remote';
+import { Strarray } from './str-array';
+import { Cert } from './cert';
+
+export namespace Transport {
+    const enum FLAGS {
+        NONE = 0
+    }
+}
+
+export class Transport {
+    /**
+     * å
+     *
+     * @static
+     * @param {Remote} owner
+     * @param {Strarray} payload
+     * @returns {Promise<Transport>}
+     *
+     * @memberof Transport
+     */
+    static sshWithPaths(owner: Remote, payload: Strarray): Promise<Transport>;
+    /**
+     *
+     *
+     * @static
+     * @param {string} prefix
+     * @returns {number}
+     *
+     * @memberof Transport
+     */
+    static unregister(prefix: string): number;
+    /**
+     *
+     *
+     * @param {number} version
+     * @returns {number}
+     *
+     * @memberof Transport
+     */
+    init(version: number): number;
+    /**
+     *
+     *
+     * @param {Cert} cert
+     * @param {number} valid
+     * @param {string} hostName
+     * @returns {number}
+     *
+     * @memberof Transport
+     */
+    smartCertificateCheck(cert: Cert, valid: number, hostName: string): number;
+}

types/nodegit/tree-builder.d.ts

@@ -0,0 +1,78 @@
+import { Oid } from './oid';
+import { Repository } from './repository';
+import { Tree } from './tree';
+import { TreeEntry } from './tree-entry';
+
+export class Treebuilder {
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Tree} source
+     * @returns {Promise<Treebuilder>}
+     *
+     * @memberof Treebuilder
+     */
+    static create(repo: Repository, source: Tree): Promise<Treebuilder>;
+
+    /**
+     *
+     *
+     *
+     * @memberof Treebuilder
+     */
+    clear(): void;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Treebuilder
+     */
+    entrycount(): number;
+    /**
+     *
+     *
+     *
+     * @memberof Treebuilder
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @param {string} filename
+     * @returns {TreeEntry}
+     *
+     * @memberof Treebuilder
+     */
+    get(filename: string): TreeEntry;
+    /**
+     *
+     *
+     * @param {string} filename
+     * @param {Oid} id
+     * @param {number} filemode
+     * @returns {Promise<TreeEntry>}
+     *
+     * @memberof Treebuilder
+     */
+    insert(filename: string, id: Oid, filemode: number): Promise<TreeEntry>;
+    /**
+     *
+     *
+     * @param {string} filename
+     * @returns {number}
+     *
+     * @memberof Treebuilder
+     */
+    remove(filename: string): number;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Treebuilder
+     */
+    write(): Oid;
+}

types/nodegit/tree-entry.d.ts

@@ -0,0 +1,162 @@
+import { Tree } from './tree';
+import { Oid } from './oid';
+import { Blob } from './blob';
+import { Repository } from './repository';
+
+export namespace TreeEntry {
+    const enum FILEMODE {
+        UNREADABLE = 0,
+        TREE = 16384,
+        BLOB = 33188,
+        EXECUTABLE = 33261,
+        LINK = 40960,
+        COMMIT = 57344
+    }
+}
+
+export class TreeEntry {
+    /**
+     *
+     *
+     * @returns {TreeEntry.FILEMODE}
+     *
+     * @memberof TreeEntry
+     */
+    filemode(): TreeEntry.FILEMODE;
+    /**
+     *
+     *
+     * @returns {TreeEntry.FILEMODE}
+     *
+     * @memberof TreeEntry
+     */
+    filemodeRaw(): TreeEntry.FILEMODE;
+    /**
+     *
+     *
+     *
+     * @memberof TreeEntry
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {Promise<Blob>}
+     *
+     * @memberof TreeEntry
+     */
+    getBlob(): Promise<Blob>;
+    /**
+     *
+     *
+     * @returns {Promise<Tree>}
+     *
+     * @memberof TreeEntry
+     */
+    getTree(): Promise<Tree>;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof TreeEntry
+     */
+    id(): Oid;
+    /**
+     *
+     *
+     * @returns {boolean}
+     *
+     * @memberof TreeEntry
+     */
+    isBlob(): boolean;
+    /**
+     *
+     *
+     * @returns {boolean}
+     *
+     * @memberof TreeEntry
+     */
+    isFile(): boolean;
+    /**
+     *
+     *
+     * @returns {boolean}
+     *
+     * @memberof TreeEntry
+     */
+    isTree(): boolean;
+    /**
+     *
+     *
+     * @returns {boolean}
+     *
+     * @memberof TreeEntry
+     */
+    isDirectory(): boolean;
+    /**
+     *
+     *
+     * @returns {boolean}
+     *
+     * @memberof TreeEntry
+     */
+    isSubmodule(): boolean;
+    /**
+     * Retrieve the SHA for this TreeEntry.
+     *
+     * @returns {string}
+     *
+     * @memberof TreeEntry
+     */
+    sha(): string;
+    /**
+     *
+     *
+     * @returns {string}
+     *
+     * @memberof TreeEntry
+     */
+    name(): string;
+    /**
+     * Retrieve the SHA for this TreeEntry. Alias for sha
+     *
+     * @returns {string}
+     *
+     * @memberof TreeEntry
+     */
+    oid(): string;
+    /**
+     * Returns the path for this entry.
+     *
+     * @returns {string}
+     *
+     * @memberof TreeEntry
+     */
+    path(): string;
+    /**
+     * Alias for path
+     *
+     * @returns {string}
+     *
+     * @memberof TreeEntry
+     */
+    toString(): string;
+    /**
+     *
+     *
+     * @param {Repository} repo
+     * @returns {Object}
+     *
+     * @memberof TreeEntry
+     */
+    toObject(repo: Repository): Object;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof TreeEntry
+     */
+    type(): number;
+}

types/nodegit/tree-update.d.ts

@@ -0,0 +1,32 @@
+import { Oid } from './oid';
+
+export class TreeUpdate {
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof TreeUpdate
+     */
+    action: number;
+    /**
+     *
+     *
+     * @type {number}
+     * @memberof TreeUpdate
+     */
+    filemode: number;
+    /**
+     *
+     *
+     * @type {Oid}
+     * @memberof TreeUpdate
+     */
+    id: Oid;
+    /**
+     *
+     *
+     * @type {string}
+     * @memberof TreeUpdate
+     */
+    path: string;
+}

types/nodegit/tree.d.ts

@@ -0,0 +1,221 @@
+import { Oid } from './oid';
+import { TreeEntry } from './tree-entry';
+import { Repository } from './repository';
+import { Object } from './object';
+import { Treebuilder } from './tree-builder';
+import { DiffFile } from './diff-file';
+import { TreeUpdate } from './tree-update';
+
+export namespace Tree {
+    const enum WALK_MODE {
+        WALK_PRE = 0,
+        WALK_POST = 1
+    }
+}
+
+export class Tree {
+    /**
+     *
+     *
+     * @static
+     * @param {TreeEntry} tree1
+     * @param {TreeEntry} tree2
+     * @returns {number}
+     *
+     * @memberof Tree
+     */
+    static entryCmp(tree1: TreeEntry, tree2: TreeEntry): number;
+    /**
+     *
+     *
+     * @static
+     * @param {TreeEntry} dest
+     * @param {TreeEntry} source
+     * @returns {number}
+     *
+     * @memberof Tree
+     */
+    static entryDup(dest: TreeEntry, source: TreeEntry): number;
+    /**
+     *
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {Oid} id
+     * @param {number} len
+     * @returns {Promise<Tree>}
+     *
+     * @memberof Tree
+     */
+    static lookupPrefix(repo: Repository, id: Oid, len: number): Promise<Tree>;
+    /**
+     * Retrieves the tree pointed to by the oid
+     *
+     * @static
+     * @param {Repository} repo
+     * @param {(string | Oid | Tree)} id
+     * @param {Function} callback
+     * @returns {Promise<Tree>}
+     *
+     * @memberof Tree
+     */
+    static lookup(repo: Repository, id: string | Oid | Tree, callback: Function): Promise<Tree>;
+
+    /**
+     *
+     *
+     * @param {Oid} id
+     * @returns {TreeEntry}
+     *
+     * @memberof Tree
+     */
+    entryById(id: Oid): TreeEntry;
+    /**
+     *
+     *
+     * @param {number} idx
+     * @returns {TreeEntry}
+     *
+     * @memberof Tree
+     */
+    _entryByIndex(idx: number): TreeEntry;
+    /**
+     * Get an entry by name; if the tree is a directory, the name is the filename.
+     *
+     * @param {string} name
+     * @returns {TreeEntry}
+     *
+     * @memberof Tree
+     */
+    entryByName(name: string): TreeEntry;
+    /**
+     *
+     *
+     * @param {string} filename
+     * @returns {TreeEntry}
+     *
+     * @memberof Tree
+     */
+    _entryByName(filename: string): TreeEntry;
+    /**
+     *
+     *
+     * @param {string} path
+     * @returns {Promise<TreeEntry>}
+     *
+     * @memberof Tree
+     */
+    entryByPath(path: string): Promise<TreeEntry>;
+    /**
+     *
+     *
+     * @returns {number}
+     *
+     * @memberof Tree
+     */
+    entryCount(): number;
+    /**
+     *
+     *
+     *
+     * @memberof Tree
+     */
+    free(): void;
+    /**
+     *
+     *
+     * @returns {Oid}
+     *
+     * @memberof Tree
+     */
+    id(): Oid;
+    /**
+     *
+     *
+     * @returns {Repository}
+     *
+     * @memberof Tree
+     */
+    owner(): Repository;
+    /**
+     * Diff two trees
+     *
+     * @param {Tree} tree
+     * @param {Function} callback
+     * @returns {Promise<DiffFile[]>}
+     *
+     * @memberof Tree
+     */
+    diff(tree: Tree, callback: Function): Promise<DiffFile[]>;
+    /**
+     * Diff two trees with options
+     *
+     * @param {Tree} tree
+     * @param {Object} options
+     * @param {Function} callback
+     * @returns {Promise<DiffFile[]>}
+     *
+     * @memberof Tree
+     */
+    diffWithOptions(tree: Tree, options: Object, callback: Function): Promise<DiffFile[]>;
+    /**
+     * Get an entry at the ith position.
+     *
+     * @param {number} i
+     * @returns {TreeEntry}
+     *
+     * @memberof Tree
+     */
+    entryByIndex(i: number): TreeEntry;
+    /**
+     * Get an entry at a path. Unlike by name, this takes a fully qualified path, like /foo/bar/baz.javascript
+     *
+     * @param {string} filePath
+     * @returns {TreeEntry}
+     *
+     * @memberof Tree
+     */
+    getEntry(filePath: string): TreeEntry;
+    /**
+     * Return an array of the entries in this tree (excluding its children).
+     *
+     * @returns {TreeEntry[]}
+     *
+     * @memberof Tree
+     */
+    entries(): TreeEntry[];
+    /**
+     * Recursively walk the tree in breadth-first order. Fires an event for each entry.
+     *
+     * @param {boolean} [blobsOnly]
+     * @returns {NodeJS.EventEmitter}
+     *
+     * @memberof Tree
+     */
+    walk(blobsOnly?: boolean): NodeJS.EventEmitter;
+    /**
+     * Return the path of this tree, like /lib/foo/bar
+     *
+     * @returns {string}
+     *
+     * @memberof Tree
+     */
+    path(): string;
+    /**
+     * Make builder. This is helpful for modifying trees.
+     *
+     * @returns {Treebuilder}
+     *
+     * @memberof Tree
+     */
+    builder(): Treebuilder;
+    /**
+     *
+     *
+     * @returns {Promise<Tree>}
+     *
+     * @memberof Tree
+     */
+    dup(): Promise<Tree>;
+    createUpdated(repo: Repository, nUpdates: number, updates: TreeUpdate): Promise<Oid>;
+}