@types/nodegit

  • Version 0.27.10
  • Published
  • 99.1 kB
  • 1 dependency
  • MIT license

Install

npm i @types/nodegit
yarn add @types/nodegit
pnpm add @types/nodegit

Overview

TypeScript definitions for nodegit

Index

Variables

Classes

Interfaces

Namespaces

Variables

variable Promise

const Promise: PromiseConstructor;

    variable version

    const version: string;

      Classes

      class AnnotatedCommit

      class AnnotatedCommit {}

        method free

        free: () => void;

          method fromFetchhead

          static fromFetchhead: (
          repo: Repository,
          branchName: string,
          remoteUrl: string,
          id: Oid
          ) => Promise<AnnotatedCommit>;
          • Parameter repo

            repository that contains the given commit

            Parameter branchName

            name of the (remote) branch

            Parameter remoteUrl

            url of the remote

            Parameter id

            the commit object id of the remote branch

          method fromRef

          static fromRef: (repo: Repository, ref: Reference) => Promise<AnnotatedCommit>;

            method fromRevspec

            static fromRevspec: (
            repo: Repository,
            revspec: string
            ) => Promise<AnnotatedCommit>;

              method id

              id: () => Oid;

                method lookup

                static lookup: (repo: Repository, id: Oid) => Promise<AnnotatedCommit>;

                  class Apply

                  class Apply {}

                    method apply

                    static apply: (
                    repo: Repository,
                    diff: Diff,
                    location: Apply.LOCATION,
                    options: ApplyOptions
                    ) => Promise<number>;

                      method toTree

                      static toTree: (
                      repo: Repository,
                      preimage: Tree,
                      diff: Diff,
                      options: ApplyOptions
                      ) => Promise<Index>;

                        class ApplyOptions

                        class ApplyOptions {}

                          property deltaCb

                          deltaCb?: (delta: DiffDelta, payload: any) => number;

                            property hunkCb

                            hunkCb?: (hunk: ConvenientHunk, payload: any) => number;

                              property version

                              version?: number;

                                class Attr

                                class Attr {}

                                  method addMacro

                                  static addMacro: (repo: Repository, name: string, values: string) => number;

                                    method cacheFlush

                                    static cacheFlush: (repo: Repository) => void;

                                      method get

                                      static get: (
                                      repo: Repository,
                                      flags: number,
                                      path: string,
                                      name: string
                                      ) => Promise<string>;
                                      • Parameter repo

                                        The repository containing the path.

                                        Parameter flags

                                        A combination of GIT_ATTR_CHECK... flags.

                                        Parameter 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).

                                        Parameter name

                                        The name of the attribute to look up.

                                        Returns

                                        - Output of the value of the attribute. Use the GIT_ATTR_...

                                      method getMany

                                      static getMany: (
                                      repo: Repository,
                                      flags: number,
                                      path: string,
                                      numAttr: number,
                                      names: string
                                      ) => any[];
                                      • Parameter repo

                                        The repository containing the path.

                                        Parameter flags

                                        A combination of GIT_ATTR_CHECK... flags.

                                        Parameter 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).

                                        Parameter numAttr

                                        The number of attributes being looked up

                                        Parameter names

                                        An array of num_attr strings containing attribute names.

                                      method value

                                      static value: (attr: string) => number;
                                      • Parameter attr

                                        The attribute

                                        Returns

                                        - the value type for the attribute

                                      class Blame

                                      class Blame {}

                                        method buffer

                                        buffer: (buffer: string, bufferLen: number) => Promise<Blame>;

                                          method file

                                          static file: (
                                          repo: Repository,
                                          path: string,
                                          options?: BlameOptions
                                          ) => Promise<Blame>;
                                          • Retrieve the blame of a file

                                            Parameter repo

                                            Repository that contains the file

                                            Parameter path

                                            to the file to get the blame of

                                            Parameter options

                                            Options for the blame

                                          method free

                                          free: () => void;

                                            method getHunkByIndex

                                            getHunkByIndex: (index: number) => BlameHunk;
                                            • Returns

                                              - the hunk at the given index, or NULL on error

                                            method getHunkByLine

                                            getHunkByLine: (lineNo: number) => BlameHunk;
                                            • Returns

                                              - the hunk that contains the given line, or NULL on error

                                            method getHunkCount

                                            getHunkCount: () => number;

                                              method initOptions

                                              static initOptions: (opts: BlameOptions, version: number) => number;
                                              • Parameter opts

                                                The git_blame_options struct to initialize

                                                Parameter version

                                                Version of struct; pass GIT_BLAME_OPTIONS_VERSION

                                              class BlameHunk

                                              class BlameHunk {}

                                                method finalCommitId

                                                finalCommitId: () => Oid;

                                                  method finalSignature

                                                  finalSignature: () => Signature;

                                                    method finalStartLineNumber

                                                    finalStartLineNumber: () => number;

                                                      method linesInHunk

                                                      linesInHunk: () => number;

                                                        method origCommitId

                                                        origCommitId: () => Oid;

                                                          method origPath

                                                          origPath: () => string;

                                                            method origSignature

                                                            origSignature: () => Signature;

                                                              method origStartLineNumber

                                                              origStartLineNumber: () => number;

                                                                class BlameOptions

                                                                class BlameOptions {}

                                                                  property flags

                                                                  flags?: number;

                                                                    property maxLine

                                                                    maxLine?: number;

                                                                      property minLine

                                                                      minLine?: number;

                                                                        property minMatchCharacters

                                                                        minMatchCharacters?: number;

                                                                          property newestCommit

                                                                          newestCommit?: Oid;

                                                                            property oldestCommit

                                                                            oldestCommit?: Oid;

                                                                              property version

                                                                              version?: number;

                                                                                class Blob

                                                                                class Blob {}

                                                                                  method content

                                                                                  content: () => Buffer;

                                                                                    method createFromBuffer

                                                                                    static createFromBuffer: (
                                                                                    repo: Repository,
                                                                                    buffer: Buffer,
                                                                                    len: number
                                                                                    ) => Promise<Oid>;
                                                                                    • Parameter repo

                                                                                      repository where to blob will be written

                                                                                      Parameter buffer

                                                                                      data to be written into the blob

                                                                                      Parameter len

                                                                                      length of the data

                                                                                      Returns

                                                                                      - return the id of the written blob

                                                                                    method createFromDisk

                                                                                    static createFromDisk: (repo: Repository, path: string) => Promise<Oid>;
                                                                                    • Parameter repo

                                                                                      repository where the blob will be written. this repository can be bare or not

                                                                                      Parameter path

                                                                                      file from which the blob will be created

                                                                                    method createFromStream

                                                                                    static createFromStream: (
                                                                                    repo: Repository,
                                                                                    hintPath: string
                                                                                    ) => Promise<WriteStream>;

                                                                                      method createFromWorkdir

                                                                                      static createFromWorkdir: (
                                                                                      repo: Repository,
                                                                                      relativePath: string
                                                                                      ) => Promise<Oid>;
                                                                                      • Parameter repo

                                                                                        repository where the blob will be written. this repository cannot be bare

                                                                                        Parameter relativePath

                                                                                        file from which the blob will be created, relative to the repository's working dir

                                                                                        Returns

                                                                                        - 0 or an error code

                                                                                      method dup

                                                                                      dup: () => Promise<Blob>;

                                                                                        method filemode

                                                                                        filemode: () => number;

                                                                                          method filteredContent

                                                                                          static filteredContent: (
                                                                                          blob: Blob,
                                                                                          as_path: string,
                                                                                          check_for_binary_data: number
                                                                                          ) => Promise<Buffer>;

                                                                                            method free

                                                                                            free: () => void;

                                                                                              method id

                                                                                              id: () => Oid;

                                                                                                method isBinary

                                                                                                isBinary: () => number;

                                                                                                  method lookup

                                                                                                  static lookup: (repo: Repository, id: string | Oid | Blob) => Promise<Blob>;

                                                                                                    method lookupPrefix

                                                                                                    static lookupPrefix: (repo: Repository, id: Oid, len: number) => Promise<Blob>;

                                                                                                      method owner

                                                                                                      owner: () => Repository;

                                                                                                        method rawcontent

                                                                                                        rawcontent: () => Wrapper;

                                                                                                          method rawsize

                                                                                                          rawsize: () => number;

                                                                                                            method toString

                                                                                                            toString: () => string;

                                                                                                              class Branch

                                                                                                              class Branch {}

                                                                                                                method create

                                                                                                                static create: (
                                                                                                                repo: Repository,
                                                                                                                branchName: string,
                                                                                                                target: Commit,
                                                                                                                force: number
                                                                                                                ) => Promise<Reference>;

                                                                                                                  method createFromAnnotated

                                                                                                                  static createFromAnnotated: (
                                                                                                                  repository: Repository,
                                                                                                                  branchName: string,
                                                                                                                  commit: AnnotatedCommit,
                                                                                                                  force: number
                                                                                                                  ) => Reference;

                                                                                                                    method delete

                                                                                                                    static delete: (branch: Reference) => number;

                                                                                                                      method isHead

                                                                                                                      static isHead: (branch: Reference) => number;

                                                                                                                        method iteratorNew

                                                                                                                        static iteratorNew: (repo: Repository, listFlags: number) => Promise<any>;

                                                                                                                          method lookup

                                                                                                                          static lookup: (
                                                                                                                          repo: Repository,
                                                                                                                          branchName: string,
                                                                                                                          branchType: Branch.BRANCH
                                                                                                                          ) => Promise<Reference>;

                                                                                                                            method move

                                                                                                                            static move: (
                                                                                                                            branch: Reference,
                                                                                                                            newBranchName: string,
                                                                                                                            force: number
                                                                                                                            ) => Promise<Reference>;

                                                                                                                              method name

                                                                                                                              static name: (ref: Reference) => Promise<string>;

                                                                                                                                method setUpstream

                                                                                                                                static setUpstream: (
                                                                                                                                branch: Reference,
                                                                                                                                upstreamName: string | null
                                                                                                                                ) => Promise<number>;

                                                                                                                                  method upstream

                                                                                                                                  static upstream: (branch: Reference) => Promise<Reference>;

                                                                                                                                    class Buf

                                                                                                                                    class Buf {}

                                                                                                                                      property asize

                                                                                                                                      asize: number;

                                                                                                                                        property ptr

                                                                                                                                        ptr: string;

                                                                                                                                          property size

                                                                                                                                          size: number;

                                                                                                                                            method containsNul

                                                                                                                                            containsNul: () => number;

                                                                                                                                              method free

                                                                                                                                              free: () => void;

                                                                                                                                                method grow

                                                                                                                                                grow: (targetSize: number) => Promise<Buf>;

                                                                                                                                                  method isBinary

                                                                                                                                                  isBinary: () => number;

                                                                                                                                                    method set

                                                                                                                                                    set: (data: Buffer, datalen: number) => Promise<Buf>;

                                                                                                                                                      class Cert

                                                                                                                                                      class Cert {}

                                                                                                                                                        property certType

                                                                                                                                                        certType: Cert.TYPE;

                                                                                                                                                          class CertHostkey

                                                                                                                                                          class CertHostkey {}

                                                                                                                                                            property hashMd5

                                                                                                                                                            hashMd5: string;

                                                                                                                                                              property hashSha1

                                                                                                                                                              hashSha1: string;

                                                                                                                                                                property parent

                                                                                                                                                                parent: Cert;

                                                                                                                                                                  property type

                                                                                                                                                                  type: Cert.TYPE;

                                                                                                                                                                    class CertX509

                                                                                                                                                                    class CertX509 {}

                                                                                                                                                                      property data

                                                                                                                                                                      data: Buffer;

                                                                                                                                                                        property len

                                                                                                                                                                        len: number;

                                                                                                                                                                          property parent

                                                                                                                                                                          parent: Cert;

                                                                                                                                                                            class Checkout

                                                                                                                                                                            class Checkout {}

                                                                                                                                                                              method head

                                                                                                                                                                              static head: (repo: Repository, options?: CheckoutOptions) => Promise<void>;
                                                                                                                                                                              • Patch head checkout to automatically coerce objects.

                                                                                                                                                                              method index

                                                                                                                                                                              static index: (
                                                                                                                                                                              repo: Repository,
                                                                                                                                                                              The: Index,
                                                                                                                                                                              options?: CheckoutOptions
                                                                                                                                                                              ) => Promise<void>;
                                                                                                                                                                              • Patch index checkout to automatically coerce objects.

                                                                                                                                                                              method initOptions

                                                                                                                                                                              static initOptions: (opts: CheckoutOptions, version: number) => number;

                                                                                                                                                                                method tree

                                                                                                                                                                                static tree: (
                                                                                                                                                                                repo: Repository,
                                                                                                                                                                                treeish: Oid | Tree | Commit | Reference,
                                                                                                                                                                                options?: CheckoutOptions
                                                                                                                                                                                ) => Promise<void>;
                                                                                                                                                                                • Patch tree checkout to automatically coerce objects.

                                                                                                                                                                                class CheckoutOptions

                                                                                                                                                                                class CheckoutOptions {}

                                                                                                                                                                                  property ancestorLabel

                                                                                                                                                                                  ancestorLabel?: string;

                                                                                                                                                                                    property baseline

                                                                                                                                                                                    baseline?: Tree;

                                                                                                                                                                                      property baselineIndex

                                                                                                                                                                                      baselineIndex?: Index;

                                                                                                                                                                                        property checkoutStrategy

                                                                                                                                                                                        checkoutStrategy?: number;

                                                                                                                                                                                          property dirMode

                                                                                                                                                                                          dirMode?: number;

                                                                                                                                                                                            property disableFilters

                                                                                                                                                                                            disableFilters?: number;

                                                                                                                                                                                              property fileMode

                                                                                                                                                                                              fileMode?: number;

                                                                                                                                                                                                property fileOpenFlags

                                                                                                                                                                                                fileOpenFlags?: number;

                                                                                                                                                                                                  property notifyCb

                                                                                                                                                                                                  notifyCb?: any;

                                                                                                                                                                                                    property notifyFlags

                                                                                                                                                                                                    notifyFlags?: number;

                                                                                                                                                                                                      property notifyPayload

                                                                                                                                                                                                      notifyPayload?: undefined;

                                                                                                                                                                                                        property ourLabel

                                                                                                                                                                                                        ourLabel?: string;

                                                                                                                                                                                                          property paths

                                                                                                                                                                                                          paths?: string | Strarray | string[];

                                                                                                                                                                                                            property perfdataCb

                                                                                                                                                                                                            perfdataCb?: any;

                                                                                                                                                                                                              property perfdataPayload

                                                                                                                                                                                                              perfdataPayload?: undefined;

                                                                                                                                                                                                                property progressCb

                                                                                                                                                                                                                progressCb?: any;

                                                                                                                                                                                                                  property progressPayload

                                                                                                                                                                                                                  progressPayload?: undefined;

                                                                                                                                                                                                                    property targetDirectory

                                                                                                                                                                                                                    targetDirectory?: string;

                                                                                                                                                                                                                      property theirLabel

                                                                                                                                                                                                                      theirLabel?: string;

                                                                                                                                                                                                                        property version

                                                                                                                                                                                                                        version?: number;

                                                                                                                                                                                                                          class Cherrypick

                                                                                                                                                                                                                          class Cherrypick {}

                                                                                                                                                                                                                            method cherrypick

                                                                                                                                                                                                                            static cherrypick: (
                                                                                                                                                                                                                            repo: Repository,
                                                                                                                                                                                                                            commit: Commit,
                                                                                                                                                                                                                            options?: CherrypickOptions
                                                                                                                                                                                                                            ) => Promise<number>;
                                                                                                                                                                                                                            • Cherrypick a commit and, changing the index and working directory

                                                                                                                                                                                                                            method commit

                                                                                                                                                                                                                            static commit: (
                                                                                                                                                                                                                            repo: Repository,
                                                                                                                                                                                                                            cherrypickCommit: Commit,
                                                                                                                                                                                                                            ourCommit: Commit,
                                                                                                                                                                                                                            mainline: number,
                                                                                                                                                                                                                            mergeOptions?: MergeOptions
                                                                                                                                                                                                                            ) => 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.

                                                                                                                                                                                                                            method initOptions

                                                                                                                                                                                                                            static initOptions: (opts: CherrypickOptions, version: number) => number;

                                                                                                                                                                                                                              class Clone

                                                                                                                                                                                                                              class Clone {}

                                                                                                                                                                                                                                method clone

                                                                                                                                                                                                                                static clone: (
                                                                                                                                                                                                                                url: string,
                                                                                                                                                                                                                                localPath: string,
                                                                                                                                                                                                                                options?: CloneOptions
                                                                                                                                                                                                                                ) => Promise<Repository>;
                                                                                                                                                                                                                                • Patch repository cloning to automatically coerce objects.

                                                                                                                                                                                                                                method initOptions

                                                                                                                                                                                                                                static initOptions: (opts: CloneOptions, version: number) => number;

                                                                                                                                                                                                                                  class CloneOptions

                                                                                                                                                                                                                                  class CloneOptions {}

                                                                                                                                                                                                                                    property bare

                                                                                                                                                                                                                                    bare?: number;

                                                                                                                                                                                                                                      property checkoutBranch

                                                                                                                                                                                                                                      checkoutBranch?: string;

                                                                                                                                                                                                                                        property checkoutOpts

                                                                                                                                                                                                                                        checkoutOpts?: CheckoutOptions;

                                                                                                                                                                                                                                          property fetchOpts

                                                                                                                                                                                                                                          fetchOpts?: FetchOptions;

                                                                                                                                                                                                                                            property local

                                                                                                                                                                                                                                            local?: number;

                                                                                                                                                                                                                                              property remoteCbPayload

                                                                                                                                                                                                                                              remoteCbPayload?: any;

                                                                                                                                                                                                                                                property repositoryCbPayload

                                                                                                                                                                                                                                                repositoryCbPayload?: any;

                                                                                                                                                                                                                                                  property version

                                                                                                                                                                                                                                                  version?: number;

                                                                                                                                                                                                                                                    class Commit

                                                                                                                                                                                                                                                    class Commit {}

                                                                                                                                                                                                                                                      method amend

                                                                                                                                                                                                                                                      amend: (
                                                                                                                                                                                                                                                      updateRef: string,
                                                                                                                                                                                                                                                      author: Signature,
                                                                                                                                                                                                                                                      committer: Signature,
                                                                                                                                                                                                                                                      messageEncoding: string,
                                                                                                                                                                                                                                                      message: string,
                                                                                                                                                                                                                                                      tree: Tree | Oid
                                                                                                                                                                                                                                                      ) => Promise<Oid>;

                                                                                                                                                                                                                                                        method amendWithSignature

                                                                                                                                                                                                                                                        amendWithSignature: (
                                                                                                                                                                                                                                                        updateRef: string,
                                                                                                                                                                                                                                                        author: Signature,
                                                                                                                                                                                                                                                        committer: Signature,
                                                                                                                                                                                                                                                        messageEncoding: string,
                                                                                                                                                                                                                                                        message: string,
                                                                                                                                                                                                                                                        tree: Tree | Oid,
                                                                                                                                                                                                                                                        onSignature: (
                                                                                                                                                                                                                                                        data: string
                                                                                                                                                                                                                                                        ) =>
                                                                                                                                                                                                                                                        | Promise<{
                                                                                                                                                                                                                                                        code: Error.CODE;
                                                                                                                                                                                                                                                        field?: string | undefined;
                                                                                                                                                                                                                                                        signedData: string;
                                                                                                                                                                                                                                                        }>
                                                                                                                                                                                                                                                        | { code: Error.CODE; field?: string | undefined; signedData: string }
                                                                                                                                                                                                                                                        ) => Promise<Oid>;

                                                                                                                                                                                                                                                          method author

                                                                                                                                                                                                                                                          author: () => Signature;

                                                                                                                                                                                                                                                            method body

                                                                                                                                                                                                                                                            body: () => string;
                                                                                                                                                                                                                                                            • consists of a summary

                                                                                                                                                                                                                                                            method committer

                                                                                                                                                                                                                                                            committer: () => Signature;

                                                                                                                                                                                                                                                              method create

                                                                                                                                                                                                                                                              static create: (
                                                                                                                                                                                                                                                              repo: Repository,
                                                                                                                                                                                                                                                              updateRef: string,
                                                                                                                                                                                                                                                              author: Signature,
                                                                                                                                                                                                                                                              committer: Signature,
                                                                                                                                                                                                                                                              messageEncoding: string,
                                                                                                                                                                                                                                                              message: string,
                                                                                                                                                                                                                                                              tree: Tree,
                                                                                                                                                                                                                                                              parentCount: number,
                                                                                                                                                                                                                                                              parents: any[]
                                                                                                                                                                                                                                                              ) => Oid;

                                                                                                                                                                                                                                                                method createV

                                                                                                                                                                                                                                                                static createV: (
                                                                                                                                                                                                                                                                id: Oid,
                                                                                                                                                                                                                                                                repo: Repository,
                                                                                                                                                                                                                                                                updateRef: string,
                                                                                                                                                                                                                                                                author: Signature,
                                                                                                                                                                                                                                                                committer: Signature,
                                                                                                                                                                                                                                                                messageEncoding: string,
                                                                                                                                                                                                                                                                message: string,
                                                                                                                                                                                                                                                                tree: Tree,
                                                                                                                                                                                                                                                                parentCount: number
                                                                                                                                                                                                                                                                ) => number;

                                                                                                                                                                                                                                                                  method createWithSignature

                                                                                                                                                                                                                                                                  static createWithSignature: (
                                                                                                                                                                                                                                                                  repo: Repository,
                                                                                                                                                                                                                                                                  commitContent: string,
                                                                                                                                                                                                                                                                  signature: string,
                                                                                                                                                                                                                                                                  signatureField: string
                                                                                                                                                                                                                                                                  ) => Promise<Oid>;

                                                                                                                                                                                                                                                                    method date

                                                                                                                                                                                                                                                                    date: () => Date;
                                                                                                                                                                                                                                                                    • Retrieve the commit time as a Date object.

                                                                                                                                                                                                                                                                    method dup

                                                                                                                                                                                                                                                                    dup: () => Promise<Commit>;

                                                                                                                                                                                                                                                                      method free

                                                                                                                                                                                                                                                                      free: () => void;

                                                                                                                                                                                                                                                                        method getDiff

                                                                                                                                                                                                                                                                        getDiff: (callback?: Function) => Promise<Diff[]>;
                                                                                                                                                                                                                                                                        • Generate an array of diff trees showing changes between this commit and its parent(s).

                                                                                                                                                                                                                                                                        method getDiffWithOptions

                                                                                                                                                                                                                                                                        getDiffWithOptions: (options: Object, callback?: Function) => Promise<Diff[]>;
                                                                                                                                                                                                                                                                        • Generate an array of diff trees showing changes between this commit and its parent(s).

                                                                                                                                                                                                                                                                        method getEntry

                                                                                                                                                                                                                                                                        getEntry: (path: string) => Promise<TreeEntry>;
                                                                                                                                                                                                                                                                        • Retrieve the entry represented by path for this commit. Path must be relative to repository root.

                                                                                                                                                                                                                                                                        method getParents

                                                                                                                                                                                                                                                                        getParents: (limit: number, callback?: Function) => Promise<Commit[]>;
                                                                                                                                                                                                                                                                        • Retrieve the commit's parents as commit objects.

                                                                                                                                                                                                                                                                        method getSignature

                                                                                                                                                                                                                                                                        getSignature: (
                                                                                                                                                                                                                                                                        field?: string
                                                                                                                                                                                                                                                                        ) => Promise<{ signature: string; signedData: string }>;

                                                                                                                                                                                                                                                                          method getTree

                                                                                                                                                                                                                                                                          getTree: () => Promise<Tree>;
                                                                                                                                                                                                                                                                          • Get the tree associated with this commit.

                                                                                                                                                                                                                                                                          method headerField

                                                                                                                                                                                                                                                                          headerField: (field: string) => Promise<Buf>;

                                                                                                                                                                                                                                                                            method history

                                                                                                                                                                                                                                                                            history: () => HistoryEventEmitter;
                                                                                                                                                                                                                                                                            • 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 EventEmitter.

                                                                                                                                                                                                                                                                            method id

                                                                                                                                                                                                                                                                            id: () => Oid;

                                                                                                                                                                                                                                                                              method lookup

                                                                                                                                                                                                                                                                              static lookup: (repo: Repository, id: string | Oid | Commit) => Promise<Commit>;
                                                                                                                                                                                                                                                                              • Retrieves the commit pointed to by the oid

                                                                                                                                                                                                                                                                              method lookupPrefix

                                                                                                                                                                                                                                                                              static lookupPrefix: (repo: Repository, id: Oid, len: number) => Promise<Commit>;

                                                                                                                                                                                                                                                                                method message

                                                                                                                                                                                                                                                                                message: () => string;

                                                                                                                                                                                                                                                                                  method messageEncoding

                                                                                                                                                                                                                                                                                  messageEncoding: () => string;

                                                                                                                                                                                                                                                                                    method messageRaw

                                                                                                                                                                                                                                                                                    messageRaw: () => string;

                                                                                                                                                                                                                                                                                      method nthGenAncestor

                                                                                                                                                                                                                                                                                      nthGenAncestor: (n: number) => Promise<Commit>;

                                                                                                                                                                                                                                                                                        method owner

                                                                                                                                                                                                                                                                                        owner: () => Repository;

                                                                                                                                                                                                                                                                                          method parent

                                                                                                                                                                                                                                                                                          parent: (n: number) => Promise<Commit>;

                                                                                                                                                                                                                                                                                            method parentcount

                                                                                                                                                                                                                                                                                            parentcount: () => number;

                                                                                                                                                                                                                                                                                              method parentId

                                                                                                                                                                                                                                                                                              parentId: (n: number) => Oid;

                                                                                                                                                                                                                                                                                                method parents

                                                                                                                                                                                                                                                                                                parents: () => Oid[];
                                                                                                                                                                                                                                                                                                • Retrieve the commit's parent shas.

                                                                                                                                                                                                                                                                                                method rawHeader

                                                                                                                                                                                                                                                                                                rawHeader: () => string;

                                                                                                                                                                                                                                                                                                  method sha

                                                                                                                                                                                                                                                                                                  sha: () => string;
                                                                                                                                                                                                                                                                                                  • Retrieve the SHA.

                                                                                                                                                                                                                                                                                                  method summary

                                                                                                                                                                                                                                                                                                  summary: () => string;

                                                                                                                                                                                                                                                                                                    method time

                                                                                                                                                                                                                                                                                                    time: () => number;

                                                                                                                                                                                                                                                                                                      method timeMs

                                                                                                                                                                                                                                                                                                      timeMs: () => number;
                                                                                                                                                                                                                                                                                                      • Retrieve the commit time as a unix timestamp.

                                                                                                                                                                                                                                                                                                      method timeOffset

                                                                                                                                                                                                                                                                                                      timeOffset: () => number;

                                                                                                                                                                                                                                                                                                        method toString

                                                                                                                                                                                                                                                                                                        toString: () => string;
                                                                                                                                                                                                                                                                                                        • The sha of this commit

                                                                                                                                                                                                                                                                                                        method tree

                                                                                                                                                                                                                                                                                                        tree: (treeOut: Tree) => number;

                                                                                                                                                                                                                                                                                                          method treeId

                                                                                                                                                                                                                                                                                                          treeId: () => Oid;

                                                                                                                                                                                                                                                                                                            class Config

                                                                                                                                                                                                                                                                                                            class Config {}

                                                                                                                                                                                                                                                                                                              method deleteEntry

                                                                                                                                                                                                                                                                                                              deleteEntry: (name: string) => number;

                                                                                                                                                                                                                                                                                                                method deleteMultivar

                                                                                                                                                                                                                                                                                                                deleteMultivar: (name: string, regexp: string) => number;

                                                                                                                                                                                                                                                                                                                  method findGlobal

                                                                                                                                                                                                                                                                                                                  static findGlobal: () => Promise<string>;

                                                                                                                                                                                                                                                                                                                    method findProgramdata

                                                                                                                                                                                                                                                                                                                    static findProgramdata: () => Promise<Buf>;

                                                                                                                                                                                                                                                                                                                      method findSystem

                                                                                                                                                                                                                                                                                                                      static findSystem: () => Promise<Buf>;

                                                                                                                                                                                                                                                                                                                        method findXdg

                                                                                                                                                                                                                                                                                                                        static findXdg: () => Promise<Buf>;

                                                                                                                                                                                                                                                                                                                          method getBool

                                                                                                                                                                                                                                                                                                                          getBool: (name: string) => Promise<number>;

                                                                                                                                                                                                                                                                                                                            method getEntry

                                                                                                                                                                                                                                                                                                                            getEntry: (name: string) => Promise<ConfigEntry>;

                                                                                                                                                                                                                                                                                                                              method getInt32

                                                                                                                                                                                                                                                                                                                              getInt32: (name: string) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                method getInt64

                                                                                                                                                                                                                                                                                                                                getInt64: (name: string) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                  method getPath

                                                                                                                                                                                                                                                                                                                                  getPath: (name: string) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                    method getStringBuf

                                                                                                                                                                                                                                                                                                                                    getStringBuf: (name: string) => Promise<Buf>;

                                                                                                                                                                                                                                                                                                                                      method lock

                                                                                                                                                                                                                                                                                                                                      lock: (transaction: any) => number;

                                                                                                                                                                                                                                                                                                                                        method openDefault

                                                                                                                                                                                                                                                                                                                                        static openDefault: () => Promise<Config>;

                                                                                                                                                                                                                                                                                                                                          method openOndisk

                                                                                                                                                                                                                                                                                                                                          static openOndisk: (path: string) => Promise<Config>;

                                                                                                                                                                                                                                                                                                                                            method setBool

                                                                                                                                                                                                                                                                                                                                            setBool: (name: string, value: number) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                              method setInt32

                                                                                                                                                                                                                                                                                                                                              setInt32: (name: string, value: number) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                method setInt64

                                                                                                                                                                                                                                                                                                                                                setInt64: (name: string, value: number) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                  method setMultivar

                                                                                                                                                                                                                                                                                                                                                  setMultivar: (name: string, regexp: string, value: string) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                    method setString

                                                                                                                                                                                                                                                                                                                                                    setString: (name: string, value: string) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                      method snapshot

                                                                                                                                                                                                                                                                                                                                                      snapshot: () => Promise<Config>;

                                                                                                                                                                                                                                                                                                                                                        class ConvenientHunk

                                                                                                                                                                                                                                                                                                                                                        class ConvenientHunk {}

                                                                                                                                                                                                                                                                                                                                                          method header

                                                                                                                                                                                                                                                                                                                                                          header: () => string;
                                                                                                                                                                                                                                                                                                                                                          • Diff header string that represents the context of this hunk of the diff. Something like @@ -169,14 +167,12 @@ ...

                                                                                                                                                                                                                                                                                                                                                          method headerLen

                                                                                                                                                                                                                                                                                                                                                          headerLen: () => number;
                                                                                                                                                                                                                                                                                                                                                          • The length of the header

                                                                                                                                                                                                                                                                                                                                                          method lines

                                                                                                                                                                                                                                                                                                                                                          lines: () => Promise<DiffLine[]>;
                                                                                                                                                                                                                                                                                                                                                          • The lines in this hunk

                                                                                                                                                                                                                                                                                                                                                          method newLines

                                                                                                                                                                                                                                                                                                                                                          newLines: () => number;
                                                                                                                                                                                                                                                                                                                                                          • The number of new lines in the hunk

                                                                                                                                                                                                                                                                                                                                                          method newStart

                                                                                                                                                                                                                                                                                                                                                          newStart: () => number;
                                                                                                                                                                                                                                                                                                                                                          • The starting offset of the first new line in the file

                                                                                                                                                                                                                                                                                                                                                          method oldLines

                                                                                                                                                                                                                                                                                                                                                          oldLines: () => number;
                                                                                                                                                                                                                                                                                                                                                          • The number of old lines in the hunk

                                                                                                                                                                                                                                                                                                                                                          method oldStart

                                                                                                                                                                                                                                                                                                                                                          oldStart: () => number;
                                                                                                                                                                                                                                                                                                                                                          • The starting offset of the first old line in the file

                                                                                                                                                                                                                                                                                                                                                          method size

                                                                                                                                                                                                                                                                                                                                                          size: () => number;
                                                                                                                                                                                                                                                                                                                                                          • Number of lines in this hunk

                                                                                                                                                                                                                                                                                                                                                          class ConvenientPatch

                                                                                                                                                                                                                                                                                                                                                          class ConvenientPatch {}

                                                                                                                                                                                                                                                                                                                                                            method hunks

                                                                                                                                                                                                                                                                                                                                                            hunks: () => Promise<ConvenientHunk[]>;
                                                                                                                                                                                                                                                                                                                                                            • The hunks in this patch

                                                                                                                                                                                                                                                                                                                                                            method isAdded

                                                                                                                                                                                                                                                                                                                                                            isAdded: () => boolean;
                                                                                                                                                                                                                                                                                                                                                            • Is this an added patch?

                                                                                                                                                                                                                                                                                                                                                            method isConflicted

                                                                                                                                                                                                                                                                                                                                                            isConflicted: () => boolean;
                                                                                                                                                                                                                                                                                                                                                            • Is this a conflicted patch?

                                                                                                                                                                                                                                                                                                                                                            method isCopied

                                                                                                                                                                                                                                                                                                                                                            isCopied: () => boolean;
                                                                                                                                                                                                                                                                                                                                                            • Is this a copied patch?

                                                                                                                                                                                                                                                                                                                                                            method isDeleted

                                                                                                                                                                                                                                                                                                                                                            isDeleted: () => boolean;
                                                                                                                                                                                                                                                                                                                                                            • Is this a deleted patch?

                                                                                                                                                                                                                                                                                                                                                            method isIgnored

                                                                                                                                                                                                                                                                                                                                                            isIgnored: () => boolean;
                                                                                                                                                                                                                                                                                                                                                            • Is this an ignored patch?

                                                                                                                                                                                                                                                                                                                                                            method isModified

                                                                                                                                                                                                                                                                                                                                                            isModified: () => boolean;
                                                                                                                                                                                                                                                                                                                                                            • Is this an modified patch

                                                                                                                                                                                                                                                                                                                                                            method isRenamed

                                                                                                                                                                                                                                                                                                                                                            isRenamed: () => boolean;
                                                                                                                                                                                                                                                                                                                                                            • Is this a renamed patch?

                                                                                                                                                                                                                                                                                                                                                            method isTypeChange

                                                                                                                                                                                                                                                                                                                                                            isTypeChange: () => boolean;
                                                                                                                                                                                                                                                                                                                                                            • Is this a type change?

                                                                                                                                                                                                                                                                                                                                                            method isUnmodified

                                                                                                                                                                                                                                                                                                                                                            isUnmodified: () => boolean;
                                                                                                                                                                                                                                                                                                                                                            • Is this an unmodified patch?

                                                                                                                                                                                                                                                                                                                                                            method isUnreadable

                                                                                                                                                                                                                                                                                                                                                            isUnreadable: () => boolean;
                                                                                                                                                                                                                                                                                                                                                            • Is this an undreadable patch?

                                                                                                                                                                                                                                                                                                                                                            method isUntracked

                                                                                                                                                                                                                                                                                                                                                            isUntracked: () => boolean;
                                                                                                                                                                                                                                                                                                                                                            • Is this an untracked patch?

                                                                                                                                                                                                                                                                                                                                                            method lineStats

                                                                                                                                                                                                                                                                                                                                                            lineStats: () => any;
                                                                                                                                                                                                                                                                                                                                                            • The line statistics of this patch (#contexts, #added, #deleted)

                                                                                                                                                                                                                                                                                                                                                            method newFile

                                                                                                                                                                                                                                                                                                                                                            newFile: () => DiffFile;
                                                                                                                                                                                                                                                                                                                                                            • New attributes of the file

                                                                                                                                                                                                                                                                                                                                                            method oldFile

                                                                                                                                                                                                                                                                                                                                                            oldFile: () => DiffFile;
                                                                                                                                                                                                                                                                                                                                                            • Old attributes of the file

                                                                                                                                                                                                                                                                                                                                                            method size

                                                                                                                                                                                                                                                                                                                                                            size: () => number;
                                                                                                                                                                                                                                                                                                                                                            • The number of hunks in this patch

                                                                                                                                                                                                                                                                                                                                                            method status

                                                                                                                                                                                                                                                                                                                                                            status: () => number;
                                                                                                                                                                                                                                                                                                                                                            • The status of this patch (unmodified, added, deleted)

                                                                                                                                                                                                                                                                                                                                                            class Cred

                                                                                                                                                                                                                                                                                                                                                            class Cred {}

                                                                                                                                                                                                                                                                                                                                                              method defaultNew

                                                                                                                                                                                                                                                                                                                                                              static defaultNew: () => Cred;

                                                                                                                                                                                                                                                                                                                                                                method free

                                                                                                                                                                                                                                                                                                                                                                free: () => void;

                                                                                                                                                                                                                                                                                                                                                                  method hasUsername

                                                                                                                                                                                                                                                                                                                                                                  hasUsername: () => number;

                                                                                                                                                                                                                                                                                                                                                                    method sshKeyFromAgent

                                                                                                                                                                                                                                                                                                                                                                    static sshKeyFromAgent: (username: string) => Cred;

                                                                                                                                                                                                                                                                                                                                                                      method sshKeyMemoryNew

                                                                                                                                                                                                                                                                                                                                                                      static sshKeyMemoryNew: (
                                                                                                                                                                                                                                                                                                                                                                      username: string,
                                                                                                                                                                                                                                                                                                                                                                      publicKey: string,
                                                                                                                                                                                                                                                                                                                                                                      privateKey: string,
                                                                                                                                                                                                                                                                                                                                                                      passphrase: string
                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<Cred>;

                                                                                                                                                                                                                                                                                                                                                                        method sshKeyNew

                                                                                                                                                                                                                                                                                                                                                                        static sshKeyNew: (
                                                                                                                                                                                                                                                                                                                                                                        username: string,
                                                                                                                                                                                                                                                                                                                                                                        publicKey: string,
                                                                                                                                                                                                                                                                                                                                                                        privateKey: string,
                                                                                                                                                                                                                                                                                                                                                                        passphrase: string
                                                                                                                                                                                                                                                                                                                                                                        ) => Cred;

                                                                                                                                                                                                                                                                                                                                                                          method usernameNew

                                                                                                                                                                                                                                                                                                                                                                          static usernameNew: (username: string) => Promise<Cred>;

                                                                                                                                                                                                                                                                                                                                                                            method userpassPlaintextNew

                                                                                                                                                                                                                                                                                                                                                                            static userpassPlaintextNew: (username: string, password: string) => Cred;

                                                                                                                                                                                                                                                                                                                                                                              class CredUsername

                                                                                                                                                                                                                                                                                                                                                                              class CredUsername {}

                                                                                                                                                                                                                                                                                                                                                                                property parent

                                                                                                                                                                                                                                                                                                                                                                                parent: Cred;

                                                                                                                                                                                                                                                                                                                                                                                  property username

                                                                                                                                                                                                                                                                                                                                                                                  username: string;

                                                                                                                                                                                                                                                                                                                                                                                    class CredUserpassPayload

                                                                                                                                                                                                                                                                                                                                                                                    class CredUserpassPayload {}

                                                                                                                                                                                                                                                                                                                                                                                      property password

                                                                                                                                                                                                                                                                                                                                                                                      password: string;

                                                                                                                                                                                                                                                                                                                                                                                        property username

                                                                                                                                                                                                                                                                                                                                                                                        username: string;

                                                                                                                                                                                                                                                                                                                                                                                          class CvarMap

                                                                                                                                                                                                                                                                                                                                                                                          class CvarMap {}

                                                                                                                                                                                                                                                                                                                                                                                            property cvarType

                                                                                                                                                                                                                                                                                                                                                                                            cvarType: number;

                                                                                                                                                                                                                                                                                                                                                                                              property mapValue

                                                                                                                                                                                                                                                                                                                                                                                              mapValue: number;

                                                                                                                                                                                                                                                                                                                                                                                                property strMatch

                                                                                                                                                                                                                                                                                                                                                                                                strMatch: string;

                                                                                                                                                                                                                                                                                                                                                                                                  class DescribeFormatOptions

                                                                                                                                                                                                                                                                                                                                                                                                  class DescribeFormatOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                    property abbreviatedSize

                                                                                                                                                                                                                                                                                                                                                                                                    abbreviatedSize?: number;

                                                                                                                                                                                                                                                                                                                                                                                                      property alwaysUseLongFormat

                                                                                                                                                                                                                                                                                                                                                                                                      alwaysUseLongFormat?: number;

                                                                                                                                                                                                                                                                                                                                                                                                        property dirtySuffix

                                                                                                                                                                                                                                                                                                                                                                                                        dirtySuffix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                          property version

                                                                                                                                                                                                                                                                                                                                                                                                          version?: number;

                                                                                                                                                                                                                                                                                                                                                                                                            class DescribeOptions

                                                                                                                                                                                                                                                                                                                                                                                                            class DescribeOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                              property describeStrategy

                                                                                                                                                                                                                                                                                                                                                                                                              describeStrategy?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                property maxCandidatesTags

                                                                                                                                                                                                                                                                                                                                                                                                                maxCandidatesTags?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                  property onlyFollowFirstParent

                                                                                                                                                                                                                                                                                                                                                                                                                  onlyFollowFirstParent?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                    property pattern

                                                                                                                                                                                                                                                                                                                                                                                                                    pattern?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property showCommitOidAsFallback

                                                                                                                                                                                                                                                                                                                                                                                                                      showCommitOidAsFallback?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                        property version

                                                                                                                                                                                                                                                                                                                                                                                                                        version?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                          class Diff

                                                                                                                                                                                                                                                                                                                                                                                                                          class Diff {}

                                                                                                                                                                                                                                                                                                                                                                                                                            method blobToBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                            static blobToBuffer: (
                                                                                                                                                                                                                                                                                                                                                                                                                            oldBlob?: Blob,
                                                                                                                                                                                                                                                                                                                                                                                                                            oldAsPath?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                            buffer?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                            bufferAsPath?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: DiffOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                            fileCb?: Function,
                                                                                                                                                                                                                                                                                                                                                                                                                            binaryCb?: Function,
                                                                                                                                                                                                                                                                                                                                                                                                                            hunkCb?: Function,
                                                                                                                                                                                                                                                                                                                                                                                                                            lineCb?: Function
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Directly run a diff between a blob and a buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                            method findSimilar

                                                                                                                                                                                                                                                                                                                                                                                                                            findSimilar: (options?: DiffFindOptions) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                              method fromBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                              static fromBuffer: (content: string, contentLen: number) => Promise<Diff>;

                                                                                                                                                                                                                                                                                                                                                                                                                                method getDelta

                                                                                                                                                                                                                                                                                                                                                                                                                                getDelta: (idx: number) => DiffDelta;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method getPerfdata

                                                                                                                                                                                                                                                                                                                                                                                                                                  getPerfdata: () => Promise<DiffPerfdata>;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method getStats

                                                                                                                                                                                                                                                                                                                                                                                                                                    getStats: () => Promise<DiffStats>;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                      - Structure containg the diff statistics.

                                                                                                                                                                                                                                                                                                                                                                                                                                    method indexToIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                    static indexToIndex: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                    oldIndex: Index,
                                                                                                                                                                                                                                                                                                                                                                                                                                    newIndex: Index,
                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: DiffOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<Diff>;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method indexToWorkdir

                                                                                                                                                                                                                                                                                                                                                                                                                                      static indexToWorkdir: (
                                                                                                                                                                                                                                                                                                                                                                                                                                      repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                      index?: Index,
                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: DiffOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<Diff>;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method merge

                                                                                                                                                                                                                                                                                                                                                                                                                                        merge: (from: Diff) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method numDeltas

                                                                                                                                                                                                                                                                                                                                                                                                                                          numDeltas: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method patches

                                                                                                                                                                                                                                                                                                                                                                                                                                            patches: () => Promise<ConvenientPatch[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Retrieve patches in this difflist

                                                                                                                                                                                                                                                                                                                                                                                                                                            method toBuf

                                                                                                                                                                                                                                                                                                                                                                                                                                            toBuf: (format: Diff.FORMAT) => Promise<Buf>;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method treeToIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                              static treeToIndex: (
                                                                                                                                                                                                                                                                                                                                                                                                                                              repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                              oldTree?: Tree,
                                                                                                                                                                                                                                                                                                                                                                                                                                              index?: Index,
                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: DiffOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<Diff>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method treeToTree

                                                                                                                                                                                                                                                                                                                                                                                                                                                static treeToTree: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                                oldTree?: Tree,
                                                                                                                                                                                                                                                                                                                                                                                                                                                new_tree?: Tree,
                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: DiffOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<Diff>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method treeToWorkdir

                                                                                                                                                                                                                                                                                                                                                                                                                                                  static treeToWorkdir: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                  repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  oldTree?: Tree,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: DiffOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<Diff>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method treeToWorkdirWithIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                    static treeToWorkdirWithIndex: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                    repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    oldTree?: Tree,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: DiffOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<Diff>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      class DiffBinary

                                                                                                                                                                                                                                                                                                                                                                                                                                                      class DiffBinary {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property containsData

                                                                                                                                                                                                                                                                                                                                                                                                                                                        containsData: DiffBinary.DIFF_BINARY;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property newFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                          newFile: DiffBinaryFile;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property oldFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                            oldFile: DiffBinaryFile;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              class DiffBinaryFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                              class DiffBinaryFile {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                data: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property datalen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  datalen: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property inflatedlen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    inflatedlen: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: Object.TYPE;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class DiffDelta

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class DiffDelta {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property flags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          flags: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property newFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            newFile: () => DiffFile;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property nfiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nfiles: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property oldFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                oldFile: () => DiffFile;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property similarity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  similarity: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    status: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class DiffFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class DiffFile {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method flags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        flags: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns the file's flags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        id: () => Oid;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns the file's Oid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mode: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns the file's mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        path: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns the file's path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        size: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns the file's size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class DiffLine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class DiffLine {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          content: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The relevant line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method contentLen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          contentLen: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method contentOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            contentOffset: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method newLineno

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              newLineno: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method numLines

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                numLines: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method oldLineno

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  oldLineno: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method origin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    origin: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method rawContent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      rawContent: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The non utf8 translated text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class DiffPerfdata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class DiffPerfdata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property oidCalculations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        oidCalculations: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property statCalls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          statCalls: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            version: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class DiffStats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class DiffStats {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method deletions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                deletions: () => Number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - total number of deletions in the diff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method filesChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                filesChanged: () => Number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - total number of files changed in the diff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method insertions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                insertions: () => Number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - total number of insertions in the diff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method toBuf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                toBuf: (format: Number, width: Number) => Promise<Buf>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Parameter format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Formatting option.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Target width for output (only affects GIT_DIFF_STATS_FULL)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - buffer to store the formatted diff statistics in.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Error {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property klass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  klass: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    message: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Fetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Fetch {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method initOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static initOptions: (opts: FetchOptions, version: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class FetchOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class FetchOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property callbacks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            callbacks?: RemoteCallbacks;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property customHeaders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              customHeaders?: string | Strarray | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property downloadTags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                downloadTags?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property proxyOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  proxyOpts?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property prune

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    prune?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property updateFetchhead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      updateFetchhead?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        version?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Filter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property attributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            attributes: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property stream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stream: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                version: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method listContains

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static listContains: (filters: any, name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method listLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static listLength: (fl: any) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method listNew

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static listNew: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      mode: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method listStreamBlob

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static listStreamBlob: (filters: any, blob: Blob, target: WriteStream) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method listStreamData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static listStreamData: (filters: any, data: Buf, target: WriteStream) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method listStreamFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static listStreamFile: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            filters: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            path: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            target: WriteStream
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method lookup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lookup: (name: string) => Filter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method register

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                register: (name: string, priority: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method unregister

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static unregister: (name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Giterr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Giterr {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method errClear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static errClear: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method errLast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static errLast: () => Error;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method errSetOom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static errSetOom: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method errSetString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static errSetString: (errorClass: number, string: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Graph

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Graph {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method aheadBehind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static aheadBehind: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                local: Oid,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                upstream: Oid
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method descendantOf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static descendantOf: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  commit: Oid,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ancestor: Oid
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Hashsig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Hashsig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method compare

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      compare: (b: Hashsig) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static create: (buf: string, buflen: number, opts: number) => Promise<Hashsig>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method createFromFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static createFromFile: (path: string, opts: number) => Promise<Hashsig>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method free

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            free: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Ignore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Ignore {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method addRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static addRule: (repo: Repository, rules: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method clearInternalRules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static clearInternalRules: (repo: Repository) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method pathIsIgnored

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static pathIsIgnored: (repo: Repository, path: string) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Index {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        add: (sourceEntry: IndexEntry) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method addAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          addAll: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pathspec?: Strarray | string | string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          flags?: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          callback?: Function
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method addByPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            addByPath: (path: string) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method caps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              caps: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method checksum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                checksum: () => Oid;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method clear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  clear: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method conflictAdd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    conflictAdd: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ancestorEntry: IndexEntry,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ourEntry: IndexEntry,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    theirEntry: IndexEntry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method conflictCleanup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      conflictCleanup: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method conflictGet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        conflictGet: (path: string) => Promise<IndexEntry>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method conflictRemove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          conflictRemove: (path: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method entries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            entries: () => IndexEntry[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method entryCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              entryCount: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method entryIsConflict

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static entryIsConflict: (entry: IndexEntry) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method entryStage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static entryStage: (entry: IndexEntry) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method findPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    findPrefix: (atPos: number, prefix: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getByIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getByIndex: (n: number) => IndexEntry;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getByPath

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method hasConflicts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hasConflicts: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static open: (indexPath: string) => Promise<Index>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method owner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              owner: () => Repository;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                path: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  read: (force: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method readTree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readTree: (tree: Tree) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      remove: (path: string, stage: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method removeAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        removeAll: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pathspec: Strarray | string | string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback?: Function
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method removeByPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          removeByPath: (path: string) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method removeDirectory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            removeDirectory: (dir: string, stage: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setCaps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setCaps: (caps: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setVersion: (version: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method updateAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  updateAll: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pathspec: Strarray | string | string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callback?: Function
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    version: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      write: () => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method writeTree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        writeTree: () => Promise<Oid>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method writeTreeTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          writeTreeTo: (repo: Repository) => Promise<Oid>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class IndexEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class IndexEntry {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ctime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ctime: IndexTime;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property dev

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                dev: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fileSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fileSize: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property flags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    flags: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property flagsExtended

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      flagsExtended: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property gid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        gid: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          id: Oid;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ino

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ino: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mode: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property mtime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mtime: IndexTime;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property uid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    uid: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Indexer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Indexer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method commit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        commit: (stats: TransferProgress) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method free

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          free: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hash: () => Oid;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Libgit2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Libgit2 {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method features

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static features: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static init: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method opts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static opts: (option: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method shutdown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static shutdown: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static version: (major: number, minor: number, rev: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Merge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Merge {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method base

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static base: (repo: Repository, one: Oid, two: Oid) => Promise<Oid>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method bases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static bases: (repo: Repository, one: Oid, two: Oid) => Promise<Oidarray>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method commits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static commits: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ourCommit: Commit,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                theirCommit: Commit,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: MergeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method fileInitInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static fileInitInput: (opts: MergeFileInput, version: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method initOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static initOptions: (opts: MergeOptions, version: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method merge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static merge: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      theirHead: AnnotatedCommit,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      mergeOpts?: MergeOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      checkoutOpts?: CheckoutOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method trees

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static trees: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ancestorTree: Tree,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ourTree: Tree,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        theirTree: Tree,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: MergeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<Index>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class MergeFileResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class MergeFileResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property automergeable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            automergeable: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property len

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              len: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mode: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ptr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ptr: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class MergeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class MergeOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultDriver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultDriver?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property fileFavor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fileFavor?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fileFlags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fileFlags?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property flags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              flags?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property recursionLimit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                recursionLimit?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property renameThreshold

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  renameThreshold?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property targetLimit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    targetLimit?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      version?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Note

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Note {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method author

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          author: () => Signature;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method committer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            committer: () => Signature;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              notesRef: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              author: Signature,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              committer: Signature,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              oid: Oid,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              note: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              force: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<Oid>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method foreach

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static foreach: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                notesRef: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                noteCb: Function,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                payload: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method free

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  free: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    id: () => Oid;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method iteratorNew

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static iteratorNew: (repo: Repository, notesRef: string) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        message: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method next

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static next: (noteId: Oid, annotatedId: Oid, it: any) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static read: (repo: Repository, notesRef: string, oid: Oid) => Promise<Note>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static remove: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              notesRef: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              author: Signature,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              committer: Signature,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              oid: Oid
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Object {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method dup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dup: () => Promise<Object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method free

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    free: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id: () => Oid;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method lookup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static lookup: (repo: Repository, id: Oid, type: Object.TYPE) => Promise<Object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method lookupByPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          lookupByPath: (path: string, type: Object.TYPE) => Promise<Object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method lookupPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static lookupPrefix: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            repo: Repository,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id: Oid,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            len: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: Object.TYPE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<Object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method owner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              owner: () => Repository;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method peel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peel: (targetType: number) => Promise<Object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method shortId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  shortId: () => Promise<Buf>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static size: (type: Object.TYPE) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method string2Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static string2Type: (str: string) => Object.TYPE;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method type2String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static type2String: (type: Object.TYPE) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method typeisloose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static typeisloose: (type: Object.TYPE) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Odb

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Odb {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method addDiskAlternate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                addDiskAlternate: (path: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method expandIds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  expandIds: (ids: OdbExpandId, count: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method free

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    free: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static open: (objectsDir: string) => Promise<Odb>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        read: (id: Oid) => Promise<OdbObject>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          write: (data: Buffer, len: number, type: Object.TYPE) => Promise<Oid>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class OdbExpandId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class OdbExpandId {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              id: Oid;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                length: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: Object.TYPE;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class OdbObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class OdbObject {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      data: () => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method dup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        dup: () => Promise<OdbObject>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method free

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          free: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id: () => Oid;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              size: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Oid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Oid {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method cmp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cmp: (b: Oid) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method cpy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cpy: () => Oid;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method equal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        equal: (b: Oid) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method fromString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static fromString: (str: string) => Oid;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method iszero

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            iszero: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method ncmp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ncmp: (b: Oid, len: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method strcmp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                strcmp: (str: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method streq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  streq: (str: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method tostrS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tostrS: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Oidarray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Oidarray {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property count

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ids

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ids: Oid;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method free

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            free: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Openssl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Openssl {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setLocking

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static setLocking: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Packbuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Packbuilder {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static create: (repo: Repository) => Packbuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method free

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      free: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hash: () => Oid;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method insert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          insert: (id: Oid, name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method insertCommit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            insertCommit: (id: Oid) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method insertRecur

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              insertRecur: (id: Oid, name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method insertTree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                insertTree: (id: Oid) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method insertWalk

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  insertWalk: (walk: Revwalk) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method objectCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    objectCount: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setThreads

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setThreads: (n: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method written

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        written: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Pathspec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Pathspec {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static create: (pathspec: Strarray | string | string[]) => Pathspec;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method free

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              free: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method matchDiff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                matchDiff: (diff: Diff, flags: number) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method matchesPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  matchesPath: (flags: number, path: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method matchIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    matchIndex: (index: Index, flags: number) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method matchListDiffEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static matchListDiffEntry: (m: any, pos: number) => DiffDelta;