nodegit.js.flow

declare module 'nodegit' {
  declare class DiffLine {

  }

  declare class ConvenientHunk {
    lines(): Promise<Array<DiffLine>>;
    header(): string;
  }

  declare class DiffFile {
    mode(): number;
    path(): string;
  }

  declare class ConvenientPatch {
    hunks(): Promise<Array<ConvenientHunk>>;
    size(): number;
    isRenamed(): boolean;
    isUntracked(): boolean;
    isAdded(): boolean;
    isRenamed(): boolean;
    isDeleted(): boolean;
    newFile(): ?DiffFile;
    oldFile(): ?DiffFile;
  }

  declare class Status {
    static OPT: {INCLUDE_UNTRACKED: number, RECURSE_UNTRACKED_DIRS: number, RENAMES_INDEX_TO_WORKDIR: number, RENAMES_HEAD_TO_INDEX: number};
  }

  declare class Diff {
    static indexToWorkdir(repo: Repository, index: Index, options: Object): Promise<Diff>;
    static treeToIndex(repo: Repository, tree: ?Tree, index: Index, options: Object): Promise<Diff>;
    static treeToWorkdirWithIndex(repo: Repository, tree: ?Tree, options: Object): Promise<Diff>;

    static OPTION: {SHOW_UNTRACKED_CONTENT: number, RECURSE_UNTRACKED_DIRS: number};
    static FIND: {RENAMES: number, FOR_UNTRACKED: number};

    patches(): Promise<Array<ConvenientPatch>>;

    findSimilar(options: Object): Promise<number>;
  }

  declare class Oid {

  }

  declare class IndexEntry {
    id: Oid;
    mode: number;
    path: string;
    fileSize: number;
    flags: number;
    flagsExtended: number;
  }

  declare class Index {
    removeByPath(path: string): number;
    addByPath(path: string): number;
    add(entry: IndexEntry): number;

    getByPath(path: string, stage?: number): ?IndexEntry;

    write(): Promise<number>;
    writeTree(): Promise<Oid>;
  }

  declare class TreeEntry {
    getBlob(): Promise<Blob>;
  }

  declare class Tree {
    getEntry(path: string): TreeEntry;
  }

  declare class Commit {
    getTree(): Promise<Tree>;
  }

  declare class Blob {
    toString(): string;
  }

  declare class StatusFile {
    path(): string;

    headToIndex(): DiffDelta;
    indexToWorkdir(): DiffDelta;

    isDeleted(): boolean;
    isRenamed(): boolean;

    inWorkingTree(): boolean;
    inIndex(): boolean;
  }

  declare class DiffDelta {
    newFile(): DiffFile;
    oldFile(): DiffFile;
  }

  declare class StatusEntry {
    headToIndex(): DiffDelta;
    indexToWorkdir(): DiffDelta;
  }

  declare class Reset {
    static default(repo: Repository, target: Commit, path: string): Promise<number>;
  }

  declare class Signature {
    static default(repo: Repository): Signature;
  }

  declare class Remote {
    name(): string;
    url(): string;

    getPushRefspecs(): Promise<Array<string>>;
    push(refspecs: ?Array<string>, options: Object): Promise<void>;

    fetch(refspecs: ?Array<string>, options: Object, message: string): Promise<void>;

    disconnect(): Promise<void>;
    stop(): void;
  }

  declare class FetchOptions {

  }

  declare class Cred {
    static userpassPlaintextNew(username: string, password: string): Cred;
    static sshKeyFromAgent(username: string): Cred;
    static defaultNew(): Cred;
  }

  declare class Reference {
    name(): string;
    shorthand(): string;
  }

  declare class Branch {
    static upstream(branch: Reference): Promise<?Reference>;
  }

  declare class Config {
    getStringBuf(name: string): ?string;
    setString(name: string, value: string): Promise<void>;
  }

  declare class TransferProgress {
    totalObjects(): number;
    receivedObjects(): number;
  }

  declare class Repository {
    static open(path: string): Promise<Repository>;

    openIndex(): Promise<Index>;

    isEmpty(): boolean;

    getHeadCommit(): Promise<Commit>;
    getCommit(sha: Oid | string): Promise<Commit>;

    getBlob(id: Oid | string): Promise<Blob>;

    createBlobFromBuffer(buf: Buffer): Oid;
    createCommit(updateRef: string, author: Signature, committer: Signature, message: string, oid: Oid, parents: ?Array<Commit>): Promise<Oid>;

    getStatusExt(): Promise<Array<StatusFile>>;

    getRemotes(): Array<string>;
    getRemote(name: string): Promise<?Remote>;

    getReference(name: string): Promise<?Reference>;
    getCurrentBranch(): Promise<Reference>;

    fetch(remote: string | Remote, options: Object | FetchOptions): Promise<void>;

    configSnapshot(): Promise<Config>;
    config(): Promise<Config>;

    mergeBranches(to: string | Reference, from: string | Reference, signature?: Signature): Promise<Oid>;
  }
}