@types/nodegit

  • Version 0.28.3
  • Published
  • 101 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

Functions

Classes

Interfaces

Namespaces

Variables

variable Promise

const Promise: PromiseConstructor;

    variable version

    const version: string;

      Functions

      function Clone

      Clone: typeof Clone;
      • Patch repository cloning to automatically coerce objects.

      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
                                                                                                                  ) => Promise<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<void>;
                                                                                                                                                                                                                            • 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 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 {}
                                                                                                                                                                                                                                                                                                                                                        • Deprecated

                                                                                                                                                                                                                                                                                                                                                          Replaced with Credential

                                                                                                                                                                                                                                                                                                                                                        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 Credential

                                                                                                                                                                                                                                                                                                                                                                        class Credential {}

                                                                                                                                                                                                                                                                                                                                                                          method defaultNew

                                                                                                                                                                                                                                                                                                                                                                          static defaultNew: () => Credential;

                                                                                                                                                                                                                                                                                                                                                                            method sshKeyFromAgent

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

                                                                                                                                                                                                                                                                                                                                                                              method sshKeyMemoryNew

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

                                                                                                                                                                                                                                                                                                                                                                                method sshKeyNew

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

                                                                                                                                                                                                                                                                                                                                                                                  method usernameNew

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

                                                                                                                                                                                                                                                                                                                                                                                    method userpassPlaintextNew

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

                                                                                                                                                                                                                                                                                                                                                                                      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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method matchListEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static matchListEntry: (m: any, pos: number) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method matchListEntrycount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static matchListEntrycount: (m: any) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method matchListFailedEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static matchListFailedEntry: (m: any, pos: number) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method matchListFailedEntrycount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static matchListFailedEntrycount: (m: any) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method matchTree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        matchTree: (tree: Tree, flags: number) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method matchWorkdir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          matchWorkdir: (repo: Repository, flags: number) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Proxy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Proxy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method initOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static initOptions