@types/nodegit

Version 0.28.9
Published 2 months ago
99.4 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

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 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 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 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 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 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 {}

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 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>;

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 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 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 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 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 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;

class Openssl

class Openssl {}

method setLocking

static setLocking: () => number;

class Packbuilder

class Packbuilder {}

method create

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

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 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: (opts: ProxyOptions, version: number) => number;

class ProxyOptions

class ProxyOptions {}

property certificateCheck

certificateCheck?: Function;

property credentials

credentials?: Function;

property payload

payload?: any;

property type

type?: number;

property url

url?: string;

property version

version?: number;

class Push

class Push {}

method initOptions

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

class PushUpdate

class PushUpdate {}

property dst

dst: Oid;

property dstRefname

dstRefname: string;

property src

src: Oid;

property srcRefname

srcRefname: string;

class Rebase

class Rebase {}

method abort

abort: () => number;

method commit

commit: (
    author: Signature | undefined | null,
    committer: Signature,
    messageEncoding?: string | null,
    message?: string | null
) => Promise<Oid>;

method finish

finish: (signature?: Signature | null) => number;

method init

static init: (
    repo: Repository,
    branch: AnnotatedCommit | undefined | null,
    upstream?: AnnotatedCommit | null,
    onto?: AnnotatedCommit | null,
    opts?: RebaseOptions | null
) => Promise<Rebase>;

method initOptions

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

method inmemoryIndex

inmemoryIndex: (index: Index) => number;

method next

next: () => Promise<RebaseOperation>;

method open

static open: (repo: Repository, opts?: RebaseOptions) => Promise<Rebase>;

method operationByIndex

operationByIndex: (idx: number) => RebaseOperation;

method operationCurrent

operationCurrent: () => number;

method operationEntrycount

operationEntrycount: () => number;

class RebaseOperation

class RebaseOperation {}

method exec

exec: () => string | null;

method id

id: () => Oid;

method type

type: () => number | null;

class Refdb

class Refdb {}

method compress

compress: () => number;

method open

static open: (repo: Repository) => Promise<Refdb>;

class Reference

class Reference {}

method cmp

cmp: (ref2: Reference) => number;

method create

static create: (
    repo: Repository,
    name: string,
    id: Oid,
    force: number,
    logMessage: string
) => Promise<Reference>;

method createMatching

static createMatching: (
    repo: Repository,
    name: string,
    id: Oid,
    force: number,
    currentId: Oid,
    logMessage: string
) => Promise<Reference>;

method delete

delete: () => number;

method dup

dup: () => Promise<Reference>;

method dwim

static dwim: (
    repo: Repository,
    id: string | Reference,
    callback?: Function
) => Promise<Reference>;

method ensureLog

static ensureLog: (repo: Repository, refname: string) => number;

method hasLog

static hasLog: (repo: Repository, refname: string) => number;

method isBranch

isBranch: () => number;

method isConcrete

isConcrete: () => boolean;

method isHead

isHead: () => boolean;

method isNote

isNote: () => number;

method isRemote

isRemote: () => number;

method isSymbolic

isSymbolic: () => boolean;

method isTag

isTag: () => number;

method isValid

isValid: () => boolean;

method isValidName

static isValidName: (refname: string) => number;

method list

static list: (repo: Repository) => Promise<any[]>;

method lookup

static lookup: (
    repo: Repository,
    id: string | Reference,
    callback?: Function
) => Promise<Reference>;

method name

name: () => string;

method nameToId

static nameToId: (repo: Repository, name: string) => Promise<Oid>;

method normalizeName

static normalizeName: (
    bufferOut: string,
    bufferSize: number,
    name: string,
    flags: number
) => number;

method owner

owner: () => Repository;

method peel

peel: (type: Object.TYPE) => Promise<Object>;

method remove

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

method rename

rename: (
    newName: string,
    force: number,
    logMessage: string
) => Promise<Reference>;

method resolve

resolve: () => Promise<Reference>;

method setTarget

setTarget: (id: Oid, logMessage: string) => Promise<Reference>;

method shorthand

shorthand: () => string;

method symbolicCreate

static symbolicCreate: (
    repo: Repository,
    name: string,
    target: string,
    force: number,
    logMessage: string
) => Promise<Reference>;

method symbolicCreateMatching

static symbolicCreateMatching: (
    repo: Repository,
    name: string,
    target: string,
    force: number,
    currentValue: string,
    logMessage: string
) => Promise<Reference>;

method symbolicSetTarget

symbolicSetTarget: (target: string, logMessage: string) => Promise<Reference>;

method symbolicTarget

symbolicTarget: () => string;

method target

target: () => Oid;

method targetPeel

targetPeel: () => Oid;

method toString

toString: () => string;

method type

type: () => number;

class Reflog

class Reflog {}

method append

append: (id: Oid, committer: Signature, msg: string) => number;

method delete

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

method drop

drop: (idx: number, rewritePreviousEntry: number) => number;

method entryByIndex

entryByIndex: (idx: number) => ReflogEntry;

method entrycount

entrycount: () => number;

method read

static read: (repo: Repository, name: string) => Promise<Reflog>;

method rename

static rename: (repo: Repository, oldName: string, name: string) => number;

method write

write: () => number;

class ReflogEntry

class ReflogEntry {}

method committer

committer: () => Signature;

method idNew

idNew: () => Oid;

method idOld

idOld: () => Oid;

method message

message: () => string;

class Refspec

class Refspec {}

method direction

direction: () => number;

method dst

dst: () => string;

method dstMatches

dstMatches: (refname: string) => number;

method force

force: () => number;

method parse

static parse: (input: string, is_fetch: number) => Promise<Refspec>;

method src

src: () => string;

method srcMatches

srcMatches: (refname: string) => number;

method string

string: () => string;

class Remote

class Remote {}

method addFetch

static addFetch: (repo: Repository, remote: string, refspec: string) => number;

method addPush

static addPush: (repo: Repository, remote: string, refspec: string) => number;

method autotag

autotag: () => number;

method connect

connect: (
    direction: Enums.DIRECTION,
    callbacks: RemoteCallbacks,
    callback?: Function
) => Promise<number>;

method connected

connected: () => number;

method create

static create: (repo: Repository, name: string, url: string) => Promise<Remote>;

method createAnonymous

static createAnonymous: (repo: Repository, url: string) => Promise<Remote>;

method createDetached

static createDetached: (url: string) => Promise<Remote>;

method createWithFetchspec

static createWithFetchspec: (
    repo: Repository,
    name: string,
    url: string,
    fetch: string
) => Promise<Remote>;

method defaultBranch

defaultBranch: () => Promise<string>;

method delete

static delete: (repo: Repository, name: string) => Promise<number>;

method disconnect

disconnect: () => Promise<void>;

method download

download: (
    refSpecs: any[],
    opts?: FetchOptions,
    callback?: Function
) => Promise<number>;

method dup

dup: () => Promise<Remote>;

method fetch

fetch: (
    refSpecs: any[],
    opts: FetchOptions,
    message: string,
    callback?: Function
) => Promise<number>;

method getFetchRefspecs

getFetchRefspecs: () => Promise<any[]>;

method getPushRefspecs

getPushRefspecs: () => Promise<any[]>;

method getRefspec

getRefspec: (n: number) => Refspec;

method initCallbacks

static initCallbacks: (opts: RemoteCallbacks, version: number) => number;

method isValidName

static isValidName: (remoteName: string) => boolean;

method list

static list: (repo: Repository) => Promise<any[]>;

method lookup

static lookup: (
    repo: Repository,
    name: string | Remote,
    callback?: Function
) => Promise<Remote>;

method name

name: () => string;

method owner

owner: () => Repository;

method prune

prune: (callbacks: RemoteCallbacks) => number;

method pruneRefs

pruneRefs: () => number;

method push

push: (
    refSpecs: any[],
    options?: PushOptions,
    callback?: Function
) => Promise<number>;

method pushurl

pushurl: () => string;

method referenceList

referenceList: () => Promise<any[]>;

Lists advertised references from a remote. You must connect to the remote before using referenceList.

method refspecCount

refspecCount: () => number;

method rename

static rename: (
    repo: Repository,
    oldName: string,
    newName: string
) => Promise<void>;

method setAutotag

static setAutotag: (repo: Repository, remote: string, value: number) => number;

method setPushurl

static setPushurl: (repo: Repository, remote: string, url: string) => number;

method setUrl

static setUrl: (repo: Repository, remote: string, url: string) => number;

method stats

stats: () => TransferProgress;

method stop

stop: () => void;

method updateTips

updateTips: (
    callbacks: RemoteCallbacks,
    updateFetchhead: number,
    downloadTags: number,
    reflogMessage: string
) => number;

method upload

upload: (refspecs: Strarray | string | string[], opts?: PushOptions) => number;

method url

url: () => string;

class RemoteCallbacks

class RemoteCallbacks {}

property certificateCheck

certificateCheck?: Function;

property credentials

credentials?: Function;

property payload

payload?: undefined;

property transferProgress

transferProgress?: Function;

property transport

transport?: Function;

property version

version?: number;

class Repository

class Repository {}

method checkoutBranch

checkoutBranch: (
    branch: string | Reference,
    opts?: CheckoutOptions
) => Promise<Reference>;

This will set the HEAD to point to the local branch and then attempt to update the index and working tree to match the content of the latest commit on that branch

method checkoutRef

checkoutRef: (
    reference: Reference,
    opts?: CheckoutOptions
) => Promise<Reference>;

This will set the HEAD to point to the reference and then attempt to update the index and working tree to match the content of the latest commit on that reference

method cleanup

cleanup: () => Promise<void>;

method commondir

commondir: () => string;

method config

config: () => Promise<Config>;

method configSnapshot

configSnapshot: () => Promise<Config>;

method continueRebase

continueRebase: (signature: Signature, beforeNextFn: Function) => Promise<Oid>;

method createBlobFromBuffer

createBlobFromBuffer: (buffer: Buffer) => Promise<Oid>;

Create a blob from a buffer

method createBranch

createBranch: (
    name: string,
    commit: Commit | string | Oid,
    force?: boolean
) => Promise<Reference>;

Creates a branch with the passed in name pointing to the commit

method createCommit

createCommit: (
    updateRef: string,
    author: Signature,
    committer: Signature,
    message: string,
    Tree: Tree | Oid | string,
    parents: Array<string | Commit | Oid>,
    callback?: Function
) => Promise<Oid>;

method createCommitOnHead

createCommitOnHead: (
    filesToAdd: string[],
    author: Signature,
    committer: Signature,
    message: string
) => Promise<Oid>;

Creates a new commit on HEAD from the list of passed in files

method createCommitWithSignature

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

method createLightweightTag

createLightweightTag: (string: string | Oid, name: string) => Promise<Reference>;

Creates a new lightweight tag

method createRevWalk

createRevWalk: () => Revwalk;

Instantiate a new revision walker for browsing the Repository"s history. See also Commit.prototype.history()

method createTag

createTag: (string: string | Oid, name: string, message: string) => Promise<Tag>;

method defaultSignature

defaultSignature: () => Signature;

Gets the default signature for the default user and now timestamp

method deleteTagByName

deleteTagByName: (Short: string) => Promise<number>;

Deletes a tag from a repository by the tag name.

method detachHead

detachHead: () => number;

method discardLines

discardLines: (filePath: string, selectedLines: DiffLine[]) => Promise<number>;

Discard line selection of a specified file. Assumes selected lines are unstaged.

method discover

static discover: (
    startPath: string,
    acrossFs: number,
    ceilingDirs: string
) => Promise<string>;

Creates a branch with the passed in name pointing to the commit

method fetch

fetch: (remote: string | Remote, fetchOptions?: FetchOptions) => Promise<void>;

Fetches from a remote

method fetchAll

fetchAll: (fetchOptions?: FetchOptions, callback?: Function) => Promise<void>;

Fetches from all remotes. This is done in series due to deadlocking issues with fetching from many remotes that can happen.

method fetchheadForeach

fetchheadForeach: (callback?: Function) => Promise<any>;

method getBlob

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

Retrieve the blob represented by the oid.

method getBranch

getBranch: (name: string | Reference) => Promise<Reference>;

Look up a branch. Alias for getReference

method getBranchCommit

getBranchCommit: (name: string | Reference) => Promise<Commit>;

Look up a branch's most recent commit. Alias to getReferenceCommit

method getCommit

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

method getCurrentBranch

getCurrentBranch: () => Promise<Reference>;

Gets the branch that HEAD currently points to Is an alias to head()

method getHeadCommit

getHeadCommit: () => Promise<Commit>;

Retrieve the commit that HEAD is currently pointing to

method getMasterCommit

getMasterCommit: () => Promise<Commit>;

Retrieve the master branch commit.

method getNamespace

getNamespace: () => string;

method getReference

getReference: (name: string | Reference) => Promise<Reference>;

Lookup the reference with the given name.

method getReferenceCommit

getReferenceCommit: (name: string | Reference) => Promise<Commit>;

Look up a refs's commit.

method getReferenceNames

getReferenceNames: (type: Reference.TYPE) => Promise<string[]>;

Lookup reference names for a repository.

method getReferences

getReferences: () => Promise<Reference[]>;

Lookup references for a repository.

method getRemote

getRemote: (remote: string | Remote, callback?: Function) => Promise<Remote>;

Gets a remote from the repo

method getRemoteNames

getRemoteNames: () => Promise<string[]>;

Lists out the names of remotes in the given repository.

method getRemotes

getRemotes: (callback?: Function) => Promise<Remote[]>;

Lists out the remotes in the given repository.

method getStatus

getStatus: (opts?: StatusOptions) => Promise<StatusFile[]>;

Get the status of a repo to it's working directory

method getStatusExt

getStatusExt: (opts?: StatusOptions) => Promise<StatusFile[]>;

Get extended statuses of a repo to it's working directory. Status entries have status, headToIndex delta, and indexToWorkdir deltas

method getSubmoduleNames

getSubmoduleNames: () => Promise<string[]>;

Get the names of the submodules in the repository.

method getSubmodules

getSubmodules: () => Promise<Submodule[]>;

method getTag

getTag: (string: string | Oid) => Promise<Tag>;

Retrieve the tag represented by the oid.

method getTagByName

getTagByName: (Short: string) => Promise<Tag>;

Retrieve the tag represented by the tag name.

method getTree

getTree: (string: string | Oid) => Promise<Tree>;

Retrieve the tree represented by the oid.

method head

head: () => Promise<Reference>;

method headDetached

headDetached: () => number;

method headUnborn

headUnborn: () => number;

method index

index: () => Promise<Index>;

method init

static init: (path: string, isBare: number) => Promise<Repository>;

method initExt

static initExt: (
    repoPath: string,
    options?: RepositoryInitOptions
) => Promise<Repository>;

method isApplyingMailbox

isApplyingMailbox: () => boolean;

Returns true if the repository is in the APPLY_MAILBOX or APPLY_MAILBOX_OR_REBASE state.

method isBare

isBare: () => number;

method isBisecting

isBisecting: () => boolean;

Returns true if the repository is in the BISECT state.

method isCherrypicking

isCherrypicking: () => boolean;

Returns true if the repository is in the CHERRYPICK state.

method isDefaultState

isDefaultState: () => boolean;

Returns true if the repository is in the default NONE state.

method isEmpty

isEmpty: () => number;

method isMerging

isMerging: () => boolean;

Returns true if the repository is in the MERGE state.

method isRebasing

isRebasing: () => boolean;

Returns true if the repository is in the REBASE, REBASE_INTERACTIVE, or REBASE_MERGE state.

method isReverting

isReverting: () => boolean;

Returns true if the repository is in the REVERT state.

method isShallow

isShallow: () => number;

method itemPath

itemPath: (item: number) => Promise<string>;

method mergeBranches

mergeBranches: (
    to: string | Reference,
    from: string | Reference,
    signature?: Signature,
    mergePreference?: Merge.PREFERENCE,
    mergeOptions?: MergeOptions
) => Promise<Oid>;

method mergeheadForeach

mergeheadForeach: (callback?: Function) => Promise<any>;

method messageRemove

messageRemove: () => number;

method odb

odb: () => Promise<Odb>;

method open

static open: (path: string) => Promise<Repository>;

method openBare

static openBare: (barePath: string) => Promise<Repository>;

method openExt

static openExt: (
    path: string,
    flags?: number,
    ceilingDirs?: string
) => Promise<Repository>;

method openFromWorktree

static openFromWorktree: (wt: Worktree) => Promise<Repository>;

method path

path: () => string;

method rebaseBranches

rebaseBranches: (
    branch: string,
    upstream: string,
    onto: string,
    signature: Signature,
    beforeNextFn: Function
) => Promise<Oid>;

Rebases a branch onto another branch

method refdb

refdb: () => Promise<Refdb>;

method refreshIndex

refreshIndex: () => Promise<Index>;

Grabs a fresh copy of the index from the repository. Invalidates all previously grabbed indexes

method refreshReferences

refreshReferences: () => Promise<void>;

method setHead

setHead: (refname: string) => Promise<number>;

method setHeadDetached

setHeadDetached: (commitish: Oid) => number;

method setHeadDetachedFromAnnotated

setHeadDetachedFromAnnotated: (commitish: AnnotatedCommit) => number;

method setIdent

setIdent: (name: string, email: string) => number;

method setNamespace

setNamespace: (nmspace: string) => number;

method setWorkdir

setWorkdir: (workdir: string, updateGitLink: number) => number;

method stageFilemode

stageFilemode: (
    filePath: string | string[],
    stageNew: boolean
) => Promise<number>;

Stages or unstages line selection of a specified file

method stageLines

stageLines: (
    filePath: string,
    newLines: DiffLine[],
    isStaged: boolean
) => Promise<number>;

Stages or unstages line selection of a specified file

method state

state: () => number;

method stateCleanup

stateCleanup: () => number;

method treeBuilder

treeBuilder: (tree: Tree) => Promise<Treebuilder>;

method workdir

workdir: () => string;

method wrapOdb

static wrapOdb: (odb: Odb) => Promise<Repository>;

class Reset

class Reset {}

method default

static default: (
    repo: Repository,
    target: Commit | Tag,
    pathspecs: Strarray | string | string[]
) => Promise<number>;

Look up a refs's commit.

method fromAnnotated

static fromAnnotated: (
    repo: Repository,
    commit: AnnotatedCommit,
    resetType: number,
    checkoutOpts: CheckoutOptions
) => Promise<number>;

Sets the current head to the specified commit oid and optionally resets the index and working tree to match. This behaves like reset but takes an annotated commit, which lets you specify which extended sha syntax string was specified by a user, allowing for more exact reflog messages. See the documentation for reset.

method reset

static reset: (
    repo: Repository,
    target: Commit | Tag,
    resetType: Reset.TYPE,
    checkoutOpts?: CheckoutOptions
) => Promise<void>;

Look up a refs's commit.

class Revert

class Revert {}

method commit

static commit: (
    repo: Repository,
    revertCommit: Commit,
    ourCommit: Commit,
    mainline: number,
    mergeOptions?: MergeOptions
) => Promise<Index>;

Reverts the given commit against the given "our" commit, producing an index that reflects the result of the revert.

method revert

static revert: (
    repo: Repository,
    commit: Commit,
    givenOpts?: RevertOptions
) => Promise<number>;

class Revparse

class Revparse {}

method ext

static ext: (
    objectOut: Object,
    referenceOut: Reference,
    repo: Repository,
    spec: string
) => number;

method single

static single: (repo: Repository, spec: string) => Promise<Object>;

class Revwalk

class Revwalk {}

method commitWalk

commitWalk: (maxCount: number) => Promise<Commit[]>;

method create

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

method fastWalk

fastWalk: (maxCount: number) => Promise<Oid[]>;

method fileHistoryWalk

fileHistoryWalk: (
    filePath: string,
    maxCount: number
) => Promise<Revwalk.HistoryEntry[]>;

method getCommits

getCommits: (count: number) => Promise<Commit[]>;

method getCommitsUntil

getCommitsUntil: (checkFn: Function) => Promise<Commit[]>;

Walk the history grabbing commits until the checkFn called with the current commit returns false.

method hide

hide: (commitId: Oid) => number;

method hideGlob

hideGlob: (glob: string) => number;

method hideHead

hideHead: () => number;

method hideRef

hideRef: (refname: string) => number;

method next

next: () => Promise<Oid>;

method push

push: (id: Oid) => number;

method pushGlob

pushGlob: (glob: string) => number;

method pushHead

pushHead: () => number;

method pushRange

pushRange: (range: string) => number;

method pushRef

pushRef: (refname: string) => number;

method repository

repository: () => Repository;

method reset

reset: () => void;

method simplifyFirstParent

simplifyFirstParent: () => void;

method sorting

sorting: (...sort: number[]) => void;

Set the sort order for the revwalk. This function takes variable arguments like revwalk.sorting(NodeGit.RevWalk.Topological, NodeGit.RevWalk.Reverse).

method walk

walk: (oid: Oid, callback?: Function) => Commit;

Walk the history from the given oid. The callback is invoked for each commit; When the walk is over, the callback is invoked with (null, null).

class Signature

class Signature {}

method create

static create: (
    name: string,
    email: string,
    time: number,
    offset: number
) => Signature;

method default

static default: (repo: Repository) => Promise<Signature>;

method dup

dup: () => Promise<Signature>;

method email

email: () => string;

method fromBuffer

static fromBuffer: (buf: string) => Promise<Signature>;

method name

name: () => string;

method now

static now: (name: string, email: string) => Signature;

method toString

toString: () => string;

method when

when: () => Time;

class Stash

class Stash {}

method apply

static apply: (
    repo: Repository,
    index: number,
    options?: StashApplyOptions
) => Promise<number>;

method applyInitOptions

static applyInitOptions: (opts: StashApplyOptions, version: number) => number;

method drop

static drop: (repo: Repository, index: number) => Promise<number>;

method foreach

static foreach: (repo: Repository, callback?: Function) => Promise<number>;

method pop

static pop: (
    repo: Repository,
    index: number,
    options?: StashApplyOptions
) => Promise<number>;

method save

static save: (
    repo: Repository,
    stasher: Signature,
    message: string,
    flags: number
) => Promise<Oid>;

class Status

class Status {}

method byIndex

static byIndex: (statuslist: StatusList, idx: number) => StatusEntry;

method file

static file: (repo: Repository, path: string) => number;

method foreach

static foreach: (repo: Repository, callback?: Function) => Promise<number>;

method foreachExt

static foreachExt: (
    repo: Repository,
    opts?: StatusOptions,
    callback?: Function
) => Promise<number>;

method shouldIgnore

static shouldIgnore: (ignored: number, repo: Repository, path: string) => number;

class StatusEntry

class StatusEntry {}

method headToIndex

headToIndex: () => DiffDelta;

method indexToWorkdir

indexToWorkdir: () => DiffDelta;

method status

status: () => number;

class StatusFile

class StatusFile {}

constructor

constructor(args: StatusFileOptions);

method headToIndex

headToIndex: () => DiffDelta;

method indexToWorkdir

indexToWorkdir: () => DiffDelta;

method inIndex

inIndex: () => boolean;

method inWorkingTree

inWorkingTree: () => boolean;

method isConflicted

isConflicted: () => boolean;

method isDeleted

isDeleted: () => boolean;

method isIgnored

isIgnored: () => boolean;

method isModified

isModified: () => boolean;

method isNew

isNew: () => boolean;

method isRenamed

isRenamed: () => boolean;

method isTypechange

isTypechange: () => boolean;

method path

path: () => string;

method status

status: () => string[];

method statusBit

statusBit: () => number;

class StatusList

class StatusList {}

method create

static create: (repo: Repository, opts?: StatusOptions) => Promise<StatusList>;

method entrycount

entrycount: () => number;

method getPerfdata

getPerfdata: () => Promise<DiffPerfdata>;

class Strarray

class Strarray {}

property count

count: number;

property strings

strings: string[];

method copy

copy: (src: Strarray) => number;

class Submodule

class Submodule {}

method addFinalize

addFinalize: () => Promise<number>;

method addSetup

static addSetup: (
    repo: Repository,
    url: string,
    path: string,
    useGitLink: number
) => Promise<Submodule>;

method addToIndex

addToIndex: (writeIndex: number) => Promise<number>;

method branch

branch: () => string;

method fetchRecurseSubmodules

fetchRecurseSubmodules: () => number;

method foreach

static foreach: (repo: Repository, callback?: Function) => Promise<number>;

method headId

headId: () => Oid;

method ignore

ignore: () => number;

method indexId

indexId: () => Oid;

method init

init: (overwrite: number) => Promise<number>;

method location

location: () => Promise<number>;

method lookup

static lookup: (repo: Repository, name: string) => Promise<Submodule>;

method name

name: () => string;

method open

open: () => Promise<Repository>;

method owner

owner: () => Repository;

method path

path: () => string;

method reload

reload: (force: number) => number;

method repoInit

repoInit: (useGitLink: number) => Promise<Repository>;

method resolveUrl

static resolveUrl: (repo: Repository, url: string) => Promise<Buf>;

method setBranch

static setBranch: (repo: Repository, name: string, branch: string) => number;

method setFetchRecurseSubmodules

static setFetchRecurseSubmodules: (
    repo: Repository,
    name: string,
    fetchRecurseSubmodules: number
) => number;

method setIgnore

static setIgnore: (
    repo: Repository,
    name: string,
    ignore: number
) => Promise<number>;

method setUpdate

static setUpdate: (
    repo: Repository,
    name: string,
    update: number
) => Promise<number>;

method setUrl

static setUrl: (repo: Repository, name: string, url: string) => Promise<number>;

method status

static status: (
    repo: Repository,
    name: string,
    ignore: number
) => Promise<number>;

method sync

sync: () => Promise<number>;

method update

update: (init: number, options?: SubmoduleUpdateOptions) => Promise<number>;

Updates a submodule

method updateInitOptions

static updateInitOptions: (
    opts: SubmoduleUpdateOptions,
    version: number
) => number;

method updateStrategy

updateStrategy: () => number;

method url

url: () => string;

method wdId

wdId: () => Oid;

class Tag

class Tag {}

method annotationCreate

static annotationCreate: (
    repo: Repository,
    tagName: string,
    target: Object,
    tagger: Signature,
    message: string
) => Promise<Oid>;

method create

static create: (
    repo: Repository,
    tagName: string,
    target: Object,
    tagger: Signature,
    message: string,
    force: number
) => Promise<Oid>;

method createLightweight

static createLightweight: (
    repo: Repository,
    tagName: string,
    target: Object,
    force: number
) => Promise<Oid>;

method createWithSignature

static createWithSignature: (
    repo: Repository,
    tagName: string,
    target: Oid | string,
    tagger: Signature,
    message: string | undefined | null,
    force: number,
    signingCallback: (
        data: string
    ) =>
        | Promise<{
              code: Error.CODE;
              field?: string | undefined;
              signedData: string;
          }>
        | { code: Error.CODE; field?: string | undefined; signedData: string }
) => Promise<Oid>;

method delete

static delete: (repo: Repository, tagName: string) => Promise<number>;

method dup

dup: () => Promise<Tag>;

method id

id: () => Oid;

method list

static list: (repo: Repository) => Promise<any[]>;

method listMatch

static listMatch: (pattern: string, repo: Repository) => Promise<any[]>;

method lookup

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

Retrieves the tag pointed to by the oid

method lookupPrefix

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

method message

message: () => string;

method name

name: () => string;

method owner

owner: () => Repository;

method peel

peel: (tagTargetOut: Object) => number;

method tagger

tagger: () => Signature;

method target

target: () => Promise<Object>;

method targetId

targetId: () => Oid;

method targetType

targetType: () => number;

class Time

class Time {}

method offset

offset: () => number;

method time

time: () => number;

class TransferProgress

class TransferProgress {}

property indexedDeltas

indexedDeltas: number;

property indexedObjects

indexedObjects: number;

property localObjects

localObjects: number;

property receivedBytes

receivedBytes: number;

property receivedObjects

receivedObjects: number;

property totalDeltas

totalDeltas: number;

property totalObjects

totalObjects: number;

class Transport

class Transport {}

method init

init: (version: number) => number;

method smartCertificateCheck

smartCertificateCheck: (cert: Cert, valid: number, hostName: string) => number;

method sshWithPaths

static sshWithPaths: (
    owner: Remote,
    payload: Strarray | string | string[]
) => Promise<Transport>;

method unregister

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

class Tree

class Tree {}

method builder

builder: () => Treebuilder;

Make builder. This is helpful for modifying trees.

method createUpdated

createUpdated: (
    repo: Repository,
    nUpdates: number,
    updates: TreeUpdate
) => Promise<Oid>;

method diff

diff: (tree: Tree, callback?: Function) => Promise<Diff>;

Diff two trees

method diffWithOptions

diffWithOptions: (
    tree: Tree | null,
    options?: DiffOptions,
    callback?: Function
) => Promise<Diff>;

Diff two trees with options

method dup

dup: () => Promise<Tree>;

method entries

entries: () => TreeEntry[];

Return an array of the entries in this tree (excluding its children).

method entryById

entryById: (id: Oid) => TreeEntry;

method entryByIndex

entryByIndex: (i: number) => TreeEntry;

Get an entry at the ith position.

method entryByName

entryByName: (name: string) => TreeEntry;

Get an entry by name; if the tree is a directory, the name is the filename.

method entryByPath

entryByPath: (path: string) => Promise<TreeEntry>;

method entryCmp

static entryCmp: (tree1: TreeEntry, tree2: TreeEntry) => number;

method entryCount

entryCount: () => number;

method entryDup

static entryDup: (dest: TreeEntry, source: TreeEntry) => number;

method getEntry

getEntry: (filePath: string) => Promise<TreeEntry>;

Get an entry at a path. Unlike by name, this takes a fully qualified path, like /foo/bar/baz.javascript

method id

id: () => Oid;

method lookup

static lookup: (
    repo: Repository,
    id: string | Oid | Tree,
    callback?: Function
) => Promise<Tree>;

Retrieves the tree pointed to by the oid

method lookupPrefix

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

method owner

owner: () => Repository;

method path

path: () => string;

Return the path of this tree, like /lib/foo/bar

method walk

walk: (blobsOnly?: boolean) => NodeJS.EventEmitter & { start: () => void };

Recursively walk the tree in breadth-first order. Fires an event for each entry.

class Treebuilder

class Treebuilder {}

method clear

clear: () => void;

method create

static create: (repo: Repository, source?: Tree) => Promise<Treebuilder>;

method entrycount

entrycount: () => number;

method get

get: (filename: string) => TreeEntry;

method insert

insert: (filename: string, id: Oid, filemode: number) => Promise<TreeEntry>;

method remove

remove: (filename: string) => number;

method write

write: () => Promise<Oid>;

class TreeEntry

class TreeEntry {}

method filemode

filemode: () => TreeEntry.FILEMODE;

method filemodeRaw

filemodeRaw: () => TreeEntry.FILEMODE;

method getBlob

getBlob: () => Promise<Blob>;

method getTree

getTree: () => Promise<Tree>;

method id

id: () => Oid;

method isBlob

isBlob: () => boolean;

method isDirectory

isDirectory: () => boolean;

method isFile

isFile: () => boolean;

method isSubmodule

isSubmodule: () => boolean;

method isTree

isTree: () => boolean;

method name

name: () => string;

method oid

oid: () => string;

Retrieve the SHA for this TreeEntry. Alias for sha

method path

path: () => string;

Returns the path for this entry.

method sha

sha: () => string;

Retrieve the SHA for this TreeEntry.

method toObject

toObject: (repo: Repository) => Object;

method toString

toString: () => string;

Alias for path

method type

type: () => number;

class TreeUpdate

class TreeUpdate {}

property action

action: number;

property filemode

filemode: number;

property id

id: Oid;

property path

path: string;

class Worktree

class Worktree {}

method add

static add: (
    repo: Repository,
    name: string,
    path: string,
    opts?: WorktreeAddOptions
) => Promise<Worktree>;

Parameter repo
Repository to create working tree for
Parameter name
Name of the working tree
Parameter path
Path to create working tree at
Parameter opts
Options to modify default behavior. May be NULL

method isLocked

isLocked: (reason?: Buf) => number;

Parameter reason
Buffer to store reason in. If NULL no reason is stored.
Returns
- 0 when the working tree not locked, a value greater than zero if it is locked, less than zero if there was an error

method isPrunable

isPrunable: (opts: WorktreePruneOptions) => number;

method list

static list: (repo: Repository) => Promise<string[]>;

Parameter repo
the repo to use when listing working trees

method lock

lock: (reason: string) => number;

Parameter reason
Reason why the working tree is being locked
Returns
- 0 on success, non-zero otherwise

method lookup

static lookup: (repo: Repository, name: string) => Promise<Worktree>;

Parameter repo
The repository containing worktrees
Parameter name
Name of the working tree to look up

method name

name: () => string;

method openFromRepository

static openFromRepository: (repo: Repository) => Promise<Worktree>;

Parameter repo
Repository to look up worktree for

method path

path: () => string;

method prune

prune: (opts?: WorktreePruneOptions) => number;

Parameter opts
Specifies which checks to override. See isPrunable. May be NULL
Returns
- 0 or an error code

method unlock

unlock: () => number;

Returns
- 0 on success, 1 if worktree was not locked, error-code

method validate

validate: () => number;

Returns
- 0 when worktree is valid, error-code otherwise

Interfaces

interface CherrypickOptions

interface CherrypickOptions {}

property checkoutOpts

checkoutOpts?: CheckoutOptions | undefined;

property mainline

mainline?: number | undefined;

property mergeOpts

mergeOpts?: MergeOptions | undefined;

property version

version?: number | undefined;

interface DiffFindOptions

interface DiffFindOptions {}

property breakRewriteThreshold

breakRewriteThreshold?: number | undefined;

property copyThreshold

copyThreshold?: number | undefined;

property flags

flags?: number | undefined;

property renameFromRewriteThreshold

renameFromRewriteThreshold?: number | undefined;

property renameLimit

renameLimit?: number | undefined;

property renameThreshold

renameThreshold?: number | undefined;

property version

version?: number | undefined;

interface DiffOptions

interface DiffOptions {}

property contextLines

contextLines?: number | undefined;

property flags

flags?: number | undefined;

property idAbbrev

idAbbrev?: number | undefined;

property ignoreSubmodules

ignoreSubmodules?: number | undefined;

property interhunkLines

interhunkLines?: number | undefined;

property maxSize

maxSize?: number | undefined;

property newPrefix

newPrefix?: string | undefined;

property notifyCb

notifyCb?: Function | undefined;

property oldPrefix

oldPrefix?: string | undefined;

property pathspec

pathspec?: Strarray | string | string[] | undefined;

property payload

payload?: any;

property progressCb

progressCb?: any;

property version

version?: number | undefined;

index signature

[key: string]: any;

interface MergeFileInput

interface MergeFileInput {}

property mode

mode: number;

property path

path: string;

property ptr

ptr: string;

property size

size: number;

property version

version: number;

interface MergeFileOptions

interface MergeFileOptions {}

property ancestorLabel

ancestorLabel?: string | undefined;

property favor

favor?: number | undefined;

property flags

flags?: number | undefined;

property ourLabel

ourLabel?: string | undefined;

property theirLabel

theirLabel?: string | undefined;

property version

version?: number | undefined;

index signature

[key: string]: any;

interface PushOptions

interface PushOptions {}

property callbacks

callbacks?: RemoteCallbacks | undefined;

property customHeaders

customHeaders?: Strarray | string | string[] | undefined;

property pbParallelism

pbParallelism?: number | undefined;

property proxyOpts

proxyOpts?: ProxyOptions | undefined;

property version

version?: number | undefined;

index signature

[key: string]: any;

interface RebaseOptions

interface RebaseOptions<PayloadType = any> {}

property checkoutOptions

checkoutOptions?: CheckoutOptions | null;

property commitCreateCb

commitCreateCb?:
    | ((
          author: Signature,
          committer: Signature,
          message_encoding: string,
          message: string,
          tree: Tree,
          parent_count: number,
          parents: Oid[],
          payload?: PayloadType
      ) => Oid)
    | null;

property inmemory

inmemory?: number | null;

property mergeOptions

mergeOptions?: MergeOptions | null;

property payload

payload?: PayloadType | null;

property quiet

quiet?: number | null;

property rewriteNotesRef

rewriteNotesRef?: string | null;

property version

version?: number | null;

interface RepositoryInitOptions

interface RepositoryInitOptions {}

property description

description?: string;

property flags

flags?: number;

property initialHead

initialHead?: string;

property mode

mode?: number;

property originUrl

originUrl?: string;

property templatePath

templatePath?: string;

property version

version?: number;

property workdirPath

workdirPath?: string;

interface StatusFileOptions

interface StatusFileOptions {}

property entry

entry?: StatusEntry | undefined;

property path

path?: string | undefined;

property status

status?: number | undefined;

index signature

[key: string]: any;

interface StatusOptions

interface StatusOptions {}

property flags

flags?: number | undefined;

property pathspec

pathspec?: Strarray | string | string[] | undefined;

property show

show?: number | undefined;

property version

version?: number | undefined;

index signature

[key: string]: any;

interface SubmoduleUpdateOptions

interface SubmoduleUpdateOptions {}

property checkoutOpts

checkoutOpts?: CheckoutOptions | undefined;

property cloneCheckoutStrategy

cloneCheckoutStrategy?: number | undefined;

property fetchOpts

fetchOpts?: FetchOptions | undefined;

property version

version?: number | undefined;

index signature

[key: string]: any;

interface WorktreeAddOptions

interface WorktreeAddOptions {}

property lock

lock?: number;

property ref

ref?: Reference;

reference to use for the new worktree HEAD

property version

version?: number;

interface WorktreePruneOptions

interface WorktreePruneOptions {}

property flags

flags?: number;

A combination of Worktree.PRUNE

property version

version?: number;

Namespaces

namespace Apply

namespace Apply {}

enum FLAGS

const enum FLAGS {
    CHECK = 1,
}

member CHECK

CHECK = 1

enum LOCATION

const enum LOCATION {
    WORKDIR = 0,
    INDEX = 1,
    BOTH = 2,
}

member BOTH

BOTH = 2

member INDEX

INDEX = 1

member WORKDIR

WORKDIR = 0

namespace Attr

namespace Attr {}

enum STATES

const enum STATES {
    UNSPECIFIED_T = 0,
    TRUE_T = 1,
    FALSE_T = 2,
    VALUE_T = 3,
}

member FALSE_T

FALSE_T = 2

member TRUE_T

TRUE_T = 1

member UNSPECIFIED_T

UNSPECIFIED_T = 0

member VALUE_T

VALUE_T = 3

namespace Blame

namespace Blame {}

enum FLAG

const enum FLAG {
    NORMAL = 0,
    TRACK_COPIES_SAME_FILE = 1,
    TRACK_COPIES_SAME_COMMIT_MOVES = 2,
    TRACK_COPIES_SAME_COMMIT_COPIES = 4,
    TRACK_COPIES_ANY_COMMIT_COPIES = 8,
    FIRST_PARENT = 16,
}

member FIRST_PARENT

FIRST_PARENT = 16

member NORMAL

NORMAL = 0

member TRACK_COPIES_ANY_COMMIT_COPIES

TRACK_COPIES_ANY_COMMIT_COPIES = 8

member TRACK_COPIES_SAME_COMMIT_COPIES

TRACK_COPIES_SAME_COMMIT_COPIES = 4

member TRACK_COPIES_SAME_COMMIT_MOVES

TRACK_COPIES_SAME_COMMIT_MOVES = 2

member TRACK_COPIES_SAME_FILE

TRACK_COPIES_SAME_FILE = 1

namespace Branch

namespace Branch {}

enum BRANCH

const enum BRANCH {
    LOCAL = 1,
    REMOTE = 2,
    ALL = 3,
}

member ALL

ALL = 3

member LOCAL

LOCAL = 1

member REMOTE

REMOTE = 2

namespace Cert

namespace Cert {}

enum SSH

const enum SSH {
    MD5 = 1,
    SHA1 = 2,
}

member MD5

MD5 = 1

member SHA1

SHA1 = 2

enum TYPE

const enum TYPE {
    NONE = 0,
    X509 = 1,
    HOSTKEY_LIBSSH2 = 2,
    STRARRAY = 3,
}

member HOSTKEY_LIBSSH2

HOSTKEY_LIBSSH2 = 2

member NONE

NONE = 0

member STRARRAY

STRARRAY = 3

member X509

X509 = 1

namespace Checkout

namespace Checkout {}

enum NOTIFY

const enum NOTIFY {
    NONE = 0,
    CONFLICT = 1,
    DIRTY = 2,
    UPDATED = 4,
    UNTRACKED = 8,
    IGNORED = 16,
    ALL = 65535,
}

member ALL

ALL = 65535

member CONFLICT

CONFLICT = 1

member DIRTY

DIRTY = 2

member IGNORED

IGNORED = 16

member NONE

NONE = 0

member UNTRACKED

UNTRACKED = 8

member UPDATED

UPDATED = 4

enum STRATEGY

const enum STRATEGY {
    NONE = 0,
    SAFE = 1,
    FORCE = 2,
    RECREATE_MISSING = 4,
    ALLOW_CONFLICTS = 16,
    REMOVE_UNTRACKED = 32,
    REMOVE_IGNORED = 64,
    UPDATE_ONLY = 128,
    DONT_UPDATE_INDEX = 256,
    NO_REFRESH = 512,
    SKIP_UNMERGED = 1024,
    USE_OURS = 2048,
    USE_THEIRS = 4096,
    DISABLE_PATHSPEC_MATCH = 8192,
    SKIP_LOCKED_DIRECTORIES = 262144,
    DONT_OVERWRITE_IGNORED = 524288,
    CONFLICT_STYLE_MERGE = 1048576,
    CONFLICT_STYLE_DIFF3 = 2097152,
    DONT_REMOVE_EXISTING = 4194304,
    DONT_WRITE_INDEX = 8388608,
    UPDATE_SUBMODULES = 65536,
    UPDATE_SUBMODULES_IF_CHANGED = 131072,
}

member ALLOW_CONFLICTS

ALLOW_CONFLICTS = 16

member CONFLICT_STYLE_DIFF3

CONFLICT_STYLE_DIFF3 = 2097152

member CONFLICT_STYLE_MERGE

CONFLICT_STYLE_MERGE = 1048576

member DISABLE_PATHSPEC_MATCH

DISABLE_PATHSPEC_MATCH = 8192

member DONT_OVERWRITE_IGNORED

DONT_OVERWRITE_IGNORED = 524288

member DONT_REMOVE_EXISTING

DONT_REMOVE_EXISTING = 4194304

member DONT_UPDATE_INDEX

DONT_UPDATE_INDEX = 256

member DONT_WRITE_INDEX

DONT_WRITE_INDEX = 8388608

member FORCE

FORCE = 2

member NO_REFRESH

NO_REFRESH = 512

member NONE

NONE = 0

member RECREATE_MISSING

RECREATE_MISSING = 4

member REMOVE_IGNORED

REMOVE_IGNORED = 64

member REMOVE_UNTRACKED

REMOVE_UNTRACKED = 32

member SAFE

SAFE = 1

member SKIP_LOCKED_DIRECTORIES

SKIP_LOCKED_DIRECTORIES = 262144

member SKIP_UNMERGED

SKIP_UNMERGED = 1024

member UPDATE_ONLY

UPDATE_ONLY = 128

member UPDATE_SUBMODULES

UPDATE_SUBMODULES = 65536

member UPDATE_SUBMODULES_IF_CHANGED

UPDATE_SUBMODULES_IF_CHANGED = 131072

member USE_OURS

USE_OURS = 2048

member USE_THEIRS

USE_THEIRS = 4096

namespace Clone

namespace Clone {}

enum LOCAL

const enum LOCAL {
    AUTO = 0,
    LOCAL = 1,
    NO_LOCAL = 2,
    NO_LINKS = 3,
}

member AUTO

AUTO = 0

member LOCAL

LOCAL = 1

member NO_LINKS

NO_LINKS = 3

member NO_LOCAL

NO_LOCAL = 2

namespace Config

namespace Config {}

enum LEVEL

const enum LEVEL {
    SYSTEM = 1,
    XDG = 2,
    GLOBAL = 3,
    LOCAL = 4,
    APP = 5,
    HIGHEST_LEVEL = -1,
}

member APP

APP = 5

member GLOBAL

GLOBAL = 3

member HIGHEST_LEVEL

HIGHEST_LEVEL = -1

member LOCAL

LOCAL = 4

member SYSTEM

SYSTEM = 1

member XDG

XDG = 2

enum MAP

const enum MAP {
    FALSE = 0,
    TRUE = 1,
    INT32 = 2,
    STRING = 3,
}

member FALSE

FALSE = 0

member INT32

INT32 = 2

member STRING

STRING = 3

member TRUE

TRUE = 1

namespace Cred

namespace Cred {}

enum TYPE

const enum TYPE {
    USERPASS_PLAINTEXT = 1,
    SSH_KEY = 2,
    SSH_CUSTOM = 4,
    DEFAULT = 8,
    SSH_INTERACTIVE = 16,
    USERNAME = 32,
    SSH_MEMORY = 64,
}

member DEFAULT

DEFAULT = 8

member SSH_CUSTOM

SSH_CUSTOM = 4

member SSH_INTERACTIVE

SSH_INTERACTIVE = 16

member SSH_KEY

SSH_KEY = 2

member SSH_MEMORY

SSH_MEMORY = 64

member USERNAME

USERNAME = 32

member USERPASS_PLAINTEXT

USERPASS_PLAINTEXT = 1

namespace Credential

namespace Credential {}

enum TYPE

const enum TYPE {
    USERPASS_PLAINTEXT = 1,
    SSH_KEY = 2,
    SSH_CUSTOM = 4,
    DEFAULT = 8,
    SSH_INTERACTIVE = 16,
    USERNAME = 32,
    SSH_MEMORY = 64,
}

member DEFAULT

DEFAULT = 8

member SSH_CUSTOM

SSH_CUSTOM = 4

member SSH_INTERACTIVE

SSH_INTERACTIVE = 16

member SSH_KEY

SSH_KEY = 2

member SSH_MEMORY

SSH_MEMORY = 64

member USERNAME

USERNAME = 32

member USERPASS_PLAINTEXT

USERPASS_PLAINTEXT = 1

namespace Diff

namespace Diff {}

enum DELTA

const enum DELTA {
    UNMODIFIED = 0,
    ADDED = 1,
    DELETED = 2,
    MODIFIED = 3,
    RENAMED = 4,
    COPIED = 5,
    IGNORED = 6,
    UNTRACKED = 7,
    TYPECHANGE = 8,
    UNREADABLE = 9,
    CONFLICTED = 10,
}

member ADDED

ADDED = 1

member CONFLICTED

CONFLICTED = 10

member COPIED

COPIED = 5

member DELETED

DELETED = 2

member IGNORED

IGNORED = 6

member MODIFIED

MODIFIED = 3

member RENAMED

RENAMED = 4

member TYPECHANGE

TYPECHANGE = 8

member UNMODIFIED

UNMODIFIED = 0

member UNREADABLE

UNREADABLE = 9

member UNTRACKED

UNTRACKED = 7

enum FIND

const enum FIND {
    BY_CONFIG = 0,
    RENAMES = 1,
    RENAMES_FROM_REWRITES = 2,
    COPIES = 4,
    COPIES_FROM_UNMODIFIED = 8,
    REWRITES = 16,
    BREAK_REWRITES = 32,
    AND_BREAK_REWRITES = 48,
    FOR_UNTRACKED = 64,
    ALL = 255,
    IGNORE_LEADING_WHITESPACE = 0,
    IGNORE_WHITESPACE = 4096,
    DONT_IGNORE_WHITESPACE = 8192,
    EXACT_MATCH_ONLY = 16384,
    BREAK_REWRITES_FOR_RENAMES_ONLY = 32768,
    REMOVE_UNMODIFIED = 65536,
}

member ALL

ALL = 255

member AND_BREAK_REWRITES

AND_BREAK_REWRITES = 48

member BREAK_REWRITES

BREAK_REWRITES = 32

member BREAK_REWRITES_FOR_RENAMES_ONLY

BREAK_REWRITES_FOR_RENAMES_ONLY = 32768

member BY_CONFIG

BY_CONFIG = 0

member COPIES

COPIES = 4

member COPIES_FROM_UNMODIFIED

COPIES_FROM_UNMODIFIED = 8

member DONT_IGNORE_WHITESPACE

DONT_IGNORE_WHITESPACE = 8192

member EXACT_MATCH_ONLY

EXACT_MATCH_ONLY = 16384

member FOR_UNTRACKED

FOR_UNTRACKED = 64

member IGNORE_LEADING_WHITESPACE

IGNORE_LEADING_WHITESPACE = 0

member IGNORE_WHITESPACE

IGNORE_WHITESPACE = 4096

member REMOVE_UNMODIFIED

REMOVE_UNMODIFIED = 65536

member RENAMES

RENAMES = 1

member RENAMES_FROM_REWRITES

RENAMES_FROM_REWRITES = 2

member REWRITES

REWRITES = 16

enum FLAG

const enum FLAG {
    BINARY = 1,
    NOT_BINARY = 2,
    VALID_ID = 4,
    EXISTS = 8,
}

member BINARY

BINARY = 1

member EXISTS

EXISTS = 8

member NOT_BINARY

NOT_BINARY = 2

member VALID_ID

VALID_ID = 4

enum FORMAT

const enum FORMAT {
    PATCH = 1,
    PATCH_HEADER = 2,
    RAW = 3,
    NAME_ONLY = 4,
    NAME_STATUS = 5,
}

member NAME_ONLY

NAME_ONLY = 4

member NAME_STATUS

NAME_STATUS = 5

member PATCH

PATCH = 1

member PATCH_HEADER

PATCH_HEADER = 2

member RAW

RAW = 3

enum FORMAT_EMAIL_FLAGS

const enum FORMAT_EMAIL_FLAGS {
    FORMAT_EMAIL_NONE = 0,
    FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER = 1,
}

member FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER

FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER = 1

member FORMAT_EMAIL_NONE

FORMAT_EMAIL_NONE = 0

enum LINE

const enum LINE {
    CONTEXT = 32,
    ADDITION = 43,
    DELETION = 45,
    CONTEXT_EOFNL = 61,
    ADD_EOFNL = 62,
    DEL_EOFNL = 60,
    FILE_HDR = 70,
    HUNK_HDR = 72,
    BINARY = 66,
}

member ADD_EOFNL

ADD_EOFNL = 62

member ADDITION

ADDITION = 43

member BINARY

BINARY = 66

member CONTEXT

CONTEXT = 32

member CONTEXT_EOFNL

CONTEXT_EOFNL = 61

member DEL_EOFNL

DEL_EOFNL = 60

member DELETION

DELETION = 45

member FILE_HDR

FILE_HDR = 70

member HUNK_HDR

HUNK_HDR = 72

enum OPTION

const enum OPTION {
    NORMAL = 0,
    REVERSE = 1,
    INCLUDE_IGNORED = 2,
    RECURSE_IGNORED_DIRS = 4,
    INCLUDE_UNTRACKED = 8,
    RECURSE_UNTRACKED_DIRS = 16,
    INCLUDE_UNMODIFIED = 32,
    INCLUDE_TYPECHANGE = 64,
    INCLUDE_TYPECHANGE_TREES = 128,
    IGNORE_FILEMODE = 256,
    IGNORE_SUBMODULES = 512,
    IGNORE_CASE = 1024,
    INCLUDE_CASECHANGE = 2048,
    DISABLE_PATHSPEC_MATCH = 4096,
    SKIP_BINARY_CHECK = 8192,
    ENABLE_FAST_UNTRACKED_DIRS = 16384,
    UPDATE_INDEX = 32768,
    INCLUDE_UNREADABLE = 65536,
    INCLUDE_UNREADABLE_AS_UNTRACKED = 131072,
    FORCE_TEXT = 1048576,
    FORCE_BINARY = 2097152,
    IGNORE_WHITESPACE = 4194304,
    IGNORE_WHITESPACE_CHANGE = 8388608,
    IGNORE_WHITESPACE_EOL = 16777216,
    SHOW_UNTRACKED_CONTENT = 33554432,
    SHOW_UNMODIFIED = 67108864,
    PATIENCE = 268435456,
    MINIMAL = 536870912,
    SHOW_BINARY = 1073741824,
}

member DISABLE_PATHSPEC_MATCH

DISABLE_PATHSPEC_MATCH = 4096

member ENABLE_FAST_UNTRACKED_DIRS

ENABLE_FAST_UNTRACKED_DIRS = 16384

member FORCE_BINARY

FORCE_BINARY = 2097152

member FORCE_TEXT

FORCE_TEXT = 1048576

member IGNORE_CASE

IGNORE_CASE = 1024

member IGNORE_FILEMODE

IGNORE_FILEMODE = 256

member IGNORE_SUBMODULES

IGNORE_SUBMODULES = 512

member IGNORE_WHITESPACE

IGNORE_WHITESPACE = 4194304

member IGNORE_WHITESPACE_CHANGE

IGNORE_WHITESPACE_CHANGE = 8388608

member IGNORE_WHITESPACE_EOL

IGNORE_WHITESPACE_EOL = 16777216

member INCLUDE_CASECHANGE

INCLUDE_CASECHANGE = 2048

member INCLUDE_IGNORED

INCLUDE_IGNORED = 2

member INCLUDE_TYPECHANGE

INCLUDE_TYPECHANGE = 64

member INCLUDE_TYPECHANGE_TREES

INCLUDE_TYPECHANGE_TREES = 128

member INCLUDE_UNMODIFIED

INCLUDE_UNMODIFIED = 32

member INCLUDE_UNREADABLE

INCLUDE_UNREADABLE = 65536

member INCLUDE_UNREADABLE_AS_UNTRACKED

INCLUDE_UNREADABLE_AS_UNTRACKED = 131072

member INCLUDE_UNTRACKED

INCLUDE_UNTRACKED = 8

member MINIMAL

MINIMAL = 536870912

member NORMAL

NORMAL = 0

member PATIENCE

PATIENCE = 268435456

member RECURSE_IGNORED_DIRS

RECURSE_IGNORED_DIRS = 4

member RECURSE_UNTRACKED_DIRS

RECURSE_UNTRACKED_DIRS = 16

member REVERSE

REVERSE = 1

member SHOW_BINARY

SHOW_BINARY = 1073741824

member SHOW_UNMODIFIED

SHOW_UNMODIFIED = 67108864

member SHOW_UNTRACKED_CONTENT

SHOW_UNTRACKED_CONTENT = 33554432

member SKIP_BINARY_CHECK

SKIP_BINARY_CHECK = 8192

member UPDATE_INDEX

UPDATE_INDEX = 32768

enum STATS_FORMAT

const enum STATS_FORMAT {
    STATS_NONE = 0,
    STATS_FULL = 1,
    STATS_SHORT = 2,
    STATS_NUMBER = 4,
    STATS_INCLUDE_SUMMARY = 8,
}

member STATS_FULL

STATS_FULL = 1

member STATS_INCLUDE_SUMMARY

STATS_INCLUDE_SUMMARY = 8

member STATS_NONE

STATS_NONE = 0

member STATS_NUMBER

STATS_NUMBER = 4

member STATS_SHORT

STATS_SHORT = 2

namespace DiffBinary

namespace DiffBinary {}

enum DIFF_BINARY

const enum DIFF_BINARY {
    NONE = 0,
    LITERAL = 1,
    DELTA = 2,
}

member DELTA

DELTA = 2

member LITERAL

LITERAL = 1

member NONE

NONE = 0

namespace Enums

namespace Enums {}

enum CVAR

const enum CVAR {
    FALSE = 0,
    TRUE = 1,
    INT32 = 2,
    string = 3,
}

member FALSE

FALSE = 0

member INT32

INT32 = 2

member string

string = 3

member TRUE

TRUE = 1

enum DIRECTION

const enum DIRECTION {
    FETCH = 0,
    PUSH = 1,
}

member FETCH

FETCH = 0

member PUSH

PUSH = 1

enum FEATURE

const enum FEATURE {
    THREADS = 1,
    HTTPS = 2,
    SSH = 4,
}

member HTTPS

HTTPS = 2

member SSH

SSH = 4

member THREADS

THREADS = 1

enum IDXENTRY_EXTENDED_FLAG

const enum IDXENTRY_EXTENDED_FLAG {
    IDXENTRY_INTENT_TO_ADD = 8192,
    IDXENTRY_SKIP_WORKTREE = 16384,
    IDXENTRY_EXTENDED2 = 32768,
    S = 24576,
    IDXENTRY_UPDATE = 1,
    IDXENTRY_REMOVE = 2,
    IDXENTRY_UPTODATE = 4,
    IDXENTRY_ADDED = 8,
    IDXENTRY_HASHED = 16,
    IDXENTRY_UNHASHED = 32,
    IDXENTRY_WT_REMOVE = 64,
    IDXENTRY_CONFLICTED = 128,
    IDXENTRY_UNPACKED = 256,
    IDXENTRY_NEW_SKIP_WORKTREE = 512,
}

member IDXENTRY_ADDED

IDXENTRY_ADDED = 8

member IDXENTRY_CONFLICTED

IDXENTRY_CONFLICTED = 128

member IDXENTRY_EXTENDED2

IDXENTRY_EXTENDED2 = 32768

member IDXENTRY_HASHED

IDXENTRY_HASHED = 16

member IDXENTRY_INTENT_TO_ADD

IDXENTRY_INTENT_TO_ADD = 8192

member IDXENTRY_NEW_SKIP_WORKTREE

IDXENTRY_NEW_SKIP_WORKTREE = 512

member IDXENTRY_REMOVE

IDXENTRY_REMOVE = 2

member IDXENTRY_SKIP_WORKTREE

IDXENTRY_SKIP_WORKTREE = 16384

member IDXENTRY_UNHASHED

IDXENTRY_UNHASHED = 32

member IDXENTRY_UNPACKED

IDXENTRY_UNPACKED = 256

member IDXENTRY_UPDATE

IDXENTRY_UPDATE = 1

member IDXENTRY_UPTODATE

IDXENTRY_UPTODATE = 4

member IDXENTRY_WT_REMOVE

IDXENTRY_WT_REMOVE = 64

member S

S = 24576

enum INDXENTRY_FLAG

const enum INDXENTRY_FLAG {
    IDXENTRY_EXTENDED = 16384,
    IDXENTRY_VALID = 32768,
}

member IDXENTRY_EXTENDED

IDXENTRY_EXTENDED = 16384

member IDXENTRY_VALID

IDXENTRY_VALID = 32768

namespace Error

namespace Error {}

enum CODE

const enum CODE {
    OK = 0,
    ERROR = -1,
    ENOTFOUND = -3,
    EEXISTS = -4,
    EAMBIGUOUS = -5,
    EBUFS = -6,
    EUSER = -7,
    EBAREREPO = -8,
    EUNBORNBRANCH = -9,
    EUNMERGED = -10,
    ENONFASTFORWARD = -11,
    EINVALIDSPEC = -12,
    ECONFLICT = -13,
    ELOCKED = -14,
    EMODIFIED = -15,
    EAUTH = -16,
    ECERTIFICATE = -17,
    EAPPLIED = -18,
    EPEEL = -19,
    EEOF = -20,
    EINVALID = -21,
    EUNCOMMITTED = -22,
    EDIRECTORY = -23,
    PASSTHROUGH = -30,
    ITEROVER = -31,
}

member EAMBIGUOUS

EAMBIGUOUS = -5

member EAPPLIED

EAPPLIED = -18

member EAUTH

EAUTH = -16

member EBAREREPO

EBAREREPO = -8

member EBUFS

EBUFS = -6

member ECERTIFICATE

ECERTIFICATE = -17

member ECONFLICT

ECONFLICT = -13

member EDIRECTORY

EDIRECTORY = -23

member EEOF

EEOF = -20

member EEXISTS

EEXISTS = -4

member EINVALID

EINVALID = -21

member EINVALIDSPEC

EINVALIDSPEC = -12

member ELOCKED

ELOCKED = -14

member EMODIFIED

EMODIFIED = -15

member ENONFASTFORWARD

ENONFASTFORWARD = -11

member ENOTFOUND

ENOTFOUND = -3

member EPEEL

EPEEL = -19

member ERROR

ERROR = -1

member EUNBORNBRANCH

EUNBORNBRANCH = -9

member EUNCOMMITTED

EUNCOMMITTED = -22

member EUNMERGED

EUNMERGED = -10

member EUSER

EUSER = -7

member ITEROVER

ITEROVER = -31

member OK

OK = 0

member PASSTHROUGH

PASSTHROUGH = -30

enum ERROR

const enum ERROR {
    GITERR_NONE = 0,
    GITERR_NOMEMORY = 1,
    GITERR_OS = 2,
    GITERR_INVALID = 3,
    GITERR_REFERENCE = 4,
    GITERR_ZLIB = 5,
    GITERR_REPOSITORY = 6,
    GITERR_CONFIG = 7,
    GITERR_REGEX = 8,
    GITERR_ODB = 9,
    GITERR_INDEX = 10,
    GITERR_OBJECT = 11,
    GITERR_NET = 12,
    GITERR_TAG = 13,
    GITERR_TREE = 14,
    GITERR_INDEXER = 15,
    GITERR_SSL = 16,
    GITERR_SUBMODULE = 17,
    GITERR_THREAD = 18,
    GITERR_STASH = 19,
    GITERR_CHECKOUT = 20,
    GITERR_FETCHHEAD = 21,
    GITERR_MERGE = 22,
    GITERR_SSH = 23,
    GITERR_FILTER = 24,
    GITERR_REVERT = 25,
    GITERR_CALLBACK = 26,
    GITERR_CHERRYPICK = 27,
    GITERR_DESCRIBE = 28,
    GITERR_REBASE = 29,
    GITERR_FILESYSTEM = 30,
}

member GITERR_CALLBACK

GITERR_CALLBACK = 26

member GITERR_CHECKOUT

GITERR_CHECKOUT = 20

member GITERR_CHERRYPICK

GITERR_CHERRYPICK = 27

member GITERR_CONFIG

GITERR_CONFIG = 7

member GITERR_DESCRIBE

GITERR_DESCRIBE = 28

member GITERR_FETCHHEAD

GITERR_FETCHHEAD = 21

member GITERR_FILESYSTEM

GITERR_FILESYSTEM = 30

member GITERR_FILTER

GITERR_FILTER = 24

member GITERR_INDEX

GITERR_INDEX = 10

member GITERR_INDEXER

GITERR_INDEXER = 15

member GITERR_INVALID

GITERR_INVALID = 3

member GITERR_MERGE

GITERR_MERGE = 22

member GITERR_NET

GITERR_NET = 12

member GITERR_NOMEMORY

GITERR_NOMEMORY = 1

member GITERR_NONE

GITERR_NONE = 0

member GITERR_OBJECT

GITERR_OBJECT = 11

member GITERR_ODB

GITERR_ODB = 9

member GITERR_OS

GITERR_OS = 2

member GITERR_REBASE

GITERR_REBASE = 29

member GITERR_REFERENCE

GITERR_REFERENCE = 4

member GITERR_REGEX

GITERR_REGEX = 8

member GITERR_REPOSITORY

GITERR_REPOSITORY = 6

member GITERR_REVERT

GITERR_REVERT = 25

member GITERR_SSH

GITERR_SSH = 23

member GITERR_SSL

GITERR_SSL = 16

member GITERR_STASH

GITERR_STASH = 19

member GITERR_SUBMODULE

GITERR_SUBMODULE = 17

member GITERR_TAG

GITERR_TAG = 13

member GITERR_THREAD

GITERR_THREAD = 18

member GITERR_TREE

GITERR_TREE = 14

member GITERR_ZLIB

GITERR_ZLIB = 5

namespace Fetch

namespace Fetch {}

enum PRUNE

const enum PRUNE {
    GIT_FETCH_PRUNE_UNSPECIFIED = 0,
    GIT_FETCH_PRUNE = 1,
    GIT_FETCH_NO_PRUNE = 2,
}

member GIT_FETCH_NO_PRUNE

GIT_FETCH_NO_PRUNE = 2

member GIT_FETCH_PRUNE

GIT_FETCH_PRUNE = 1

member GIT_FETCH_PRUNE_UNSPECIFIED

GIT_FETCH_PRUNE_UNSPECIFIED = 0

namespace Filter

namespace Filter {}

enum FLAG

const enum FLAG {
    DEFAULT = 0,
    ALLOW_UNSAFE = 1,
}

member ALLOW_UNSAFE

ALLOW_UNSAFE = 1

member DEFAULT

DEFAULT = 0

enum MODE

const enum MODE {
    TO_WORKTREE = 0,
    SMUDGE = 0,
    TO_ODB = 1,
    CLEAN = 1,
}

member CLEAN

CLEAN = 1

member SMUDGE

SMUDGE = 0

member TO_ODB

TO_ODB = 1

member TO_WORKTREE

TO_WORKTREE = 0

namespace Hashsig

namespace Hashsig {}

enum OPTION

const enum OPTION {
    NORMAL = 0,
    IGNORE_WHITESPACE = 1,
    SMART_WHITESPACE = 2,
    ALLOW_SMALL_FILES = 4,
}

member ALLOW_SMALL_FILES

ALLOW_SMALL_FILES = 4

member IGNORE_WHITESPACE

IGNORE_WHITESPACE = 1

member NORMAL

NORMAL = 0

member SMART_WHITESPACE

SMART_WHITESPACE = 2

namespace Index

namespace Index {}

enum ADD_OPTION

const enum ADD_OPTION {
    ADD_DEFAULT = 0,
    ADD_FORCE = 1,
    ADD_DISABLE_PATHSPEC_MATCH = 2,
    ADD_CHECK_PATHSPEC = 4,
}

member ADD_CHECK_PATHSPEC

ADD_CHECK_PATHSPEC = 4

member ADD_DEFAULT

ADD_DEFAULT = 0

member ADD_DISABLE_PATHSPEC_MATCH

ADD_DISABLE_PATHSPEC_MATCH = 2

member ADD_FORCE

ADD_FORCE = 1

enum CAP

const enum CAP {
    IGNORE_CASE = 1,
    NO_FILEMODE = 2,
    NO_SYMLINKS = 4,
    FROM_OWNER = -1,
}

member FROM_OWNER

FROM_OWNER = -1

member IGNORE_CASE

IGNORE_CASE = 1

member NO_FILEMODE

NO_FILEMODE = 2

member NO_SYMLINKS

NO_SYMLINKS = 4

namespace Libgit2

namespace Libgit2 {}

enum OPT

const enum OPT {
    GET_MWINDOW_SIZE = 0,
    SET_MWINDOW_SIZE = 1,
    GET_MWINDOW_MAPPED_LIMIT = 2,
    SET_MWINDOW_MAPPED_LIMIT = 3,
    GET_SEARCH_PATH = 4,
    SET_SEARCH_PATH = 5,
    SET_CACHE_OBJECT_LIMIT = 6,
    SET_CACHE_MAX_SIZE = 7,
    ENABLE_CACHING = 8,
    GET_CACHED_MEMORY = 9,
    GET_TEMPLATE_PATH = 10,
    SET_TEMPLATE_PATH = 11,
    SET_SSL_CERT_LOCATIONS = 12,
}

member ENABLE_CACHING

ENABLE_CACHING = 8

member GET_CACHED_MEMORY

GET_CACHED_MEMORY = 9

member GET_MWINDOW_MAPPED_LIMIT

GET_MWINDOW_MAPPED_LIMIT = 2

member GET_MWINDOW_SIZE

GET_MWINDOW_SIZE = 0

member GET_SEARCH_PATH

GET_SEARCH_PATH = 4

member GET_TEMPLATE_PATH

GET_TEMPLATE_PATH = 10

member SET_CACHE_MAX_SIZE

SET_CACHE_MAX_SIZE = 7

member SET_CACHE_OBJECT_LIMIT

SET_CACHE_OBJECT_LIMIT = 6

member SET_MWINDOW_MAPPED_LIMIT

SET_MWINDOW_MAPPED_LIMIT = 3

member SET_MWINDOW_SIZE

SET_MWINDOW_SIZE = 1

member SET_SEARCH_PATH

SET_SEARCH_PATH = 5

member SET_SSL_CERT_LOCATIONS

SET_SSL_CERT_LOCATIONS = 12

member SET_TEMPLATE_PATH

SET_TEMPLATE_PATH = 11

namespace Merge

namespace Merge {}

enum ANALYSIS

const enum ANALYSIS {
    NONE = 0,
    NORMAL = 1,
    UP_TO_DATE = 2,
    FASTFORWARD = 4,
    UNBORN = 8,
}

member FASTFORWARD

FASTFORWARD = 4

member NONE

NONE = 0

member NORMAL

NORMAL = 1

member UNBORN

UNBORN = 8

member UP_TO_DATE

UP_TO_DATE = 2

enum FILE_FAVOR

const enum FILE_FAVOR {
    NORMAL = 0,
    OURS = 1,
    THEIRS = 2,
    UNION = 3,
}

member NORMAL

NORMAL = 0

member OURS

OURS = 1

member THEIRS

THEIRS = 2

member UNION

UNION = 3

enum FILE_FLAGS

const enum FILE_FLAGS {
    FILE_DEFAULT = 0,
    FILE_STYLE_MERGE = 1,
    FILE_STYLE_DIFF3 = 2,
    FILE_SIMPLIFY_ALNUM = 4,
    FILE_IGNORE_WHITESPACE = 8,
    FILE_IGNORE_WHITESPACE_CHANGE = 16,
    FILE_IGNORE_WHITESPACE_EOL = 32,
    FILE_DIFF_PATIENCE = 64,
    FILE_DIFF_MINIMAL = 128,
}

member FILE_DEFAULT

FILE_DEFAULT = 0

member FILE_DIFF_MINIMAL

FILE_DIFF_MINIMAL = 128

member FILE_DIFF_PATIENCE

FILE_DIFF_PATIENCE = 64

member FILE_IGNORE_WHITESPACE

FILE_IGNORE_WHITESPACE = 8

member FILE_IGNORE_WHITESPACE_CHANGE

FILE_IGNORE_WHITESPACE_CHANGE = 16

member FILE_IGNORE_WHITESPACE_EOL

FILE_IGNORE_WHITESPACE_EOL = 32

member FILE_SIMPLIFY_ALNUM

FILE_SIMPLIFY_ALNUM = 4

member FILE_STYLE_DIFF3

FILE_STYLE_DIFF3 = 2

member FILE_STYLE_MERGE

FILE_STYLE_MERGE = 1

enum PREFERENCE

const enum PREFERENCE {
    NONE = 0,
    NO_FASTFORWARD = 1,
    FASTFORWARD_ONLY = 2,
}

member FASTFORWARD_ONLY

FASTFORWARD_ONLY = 2

member NO_FASTFORWARD

NO_FASTFORWARD = 1

member NONE

NONE = 0

enum TREE_FLAG

const enum TREE_FLAG {
    TREE_FIND_RENAMES = 1,
}

member TREE_FIND_RENAMES

TREE_FIND_RENAMES = 1

namespace Object

namespace Object {}

enum TYPE

const enum TYPE {
    ANY = -2,
    BAD = -1,
    EXT1 = 0,
    COMMIT = 1,
    TREE = 2,
    BLOB = 3,
    TAG = 4,
    EXT2 = 5,
    OFS_DELTA = 6,
    REF_DELTA = 7,
}

member ANY

ANY = -2

member BAD

BAD = -1

member BLOB

BLOB = 3

member COMMIT

COMMIT = 1

member EXT1

EXT1 = 0

member EXT2

EXT2 = 5

member OFS_DELTA

OFS_DELTA = 6

member REF_DELTA

REF_DELTA = 7

member TAG

TAG = 4

member TREE

TREE = 2

namespace Odb

namespace Odb {}

enum STREAM

const enum STREAM {
    RDONLY = 2,
    WRONLY = 4,
    RW = 6,
}

member RDONLY

RDONLY = 2

member RW

RW = 6

member WRONLY

WRONLY = 4

namespace Packbuilder

namespace Packbuilder {}

enum STAGE

const enum STAGE {
    ADDING_OBJECTS = 0,
    DELTAFICATION = 1,
}

member ADDING_OBJECTS

ADDING_OBJECTS = 0

member DELTAFICATION

DELTAFICATION = 1

namespace Pathspec

namespace Pathspec {}

enum FLAG

const enum FLAG {
    DEFAULT = 0,
    IGNORE_CASE = 1,
    USE_CASE = 2,
    NO_GLOB = 4,
    NO_MATCH_ERROR = 8,
    FIND_FAILURES = 16,
    FAILURES_ONLY = 32,
}

member DEFAULT

DEFAULT = 0

member FAILURES_ONLY

FAILURES_ONLY = 32

member FIND_FAILURES

FIND_FAILURES = 16

member IGNORE_CASE

IGNORE_CASE = 1

member NO_GLOB

NO_GLOB = 4

member NO_MATCH_ERROR

NO_MATCH_ERROR = 8

member USE_CASE

USE_CASE = 2

namespace RebaseOperation

namespace RebaseOperation {}

enum REBASE_OPERATION

const enum REBASE_OPERATION {
    PICK = 0,
    REWORD = 1,
    EDIT = 2,
    SQUASH = 3,
    FIXUP = 4,
    EXEC = 5,
}

member EDIT

EDIT = 2

member EXEC

EXEC = 5

member FIXUP

FIXUP = 4

member PICK

PICK = 0

member REWORD

REWORD = 1

member SQUASH

SQUASH = 3

namespace Reference

namespace Reference {}

enum NORMALIZE

const enum NORMALIZE {
    REF_FORMAT_NORMAL = 0,
    REF_FORMAT_ALLOW_ONELEVEL = 1,
    REF_FORMAT_REFSPEC_PATTERN = 2,
    REF_FORMAT_REFSPEC_SHORTHAND = 4,
}

member REF_FORMAT_ALLOW_ONELEVEL

REF_FORMAT_ALLOW_ONELEVEL = 1

member REF_FORMAT_NORMAL

REF_FORMAT_NORMAL = 0

member REF_FORMAT_REFSPEC_PATTERN

REF_FORMAT_REFSPEC_PATTERN = 2

member REF_FORMAT_REFSPEC_SHORTHAND

REF_FORMAT_REFSPEC_SHORTHAND = 4

enum TYPE

const enum TYPE {
    INVALID = 0,
    DIRECT = 1,
    OID = 1,
    SYMBOLIC = 2,
    ALL = 3,
    LISTALL = 3,
}

member ALL

ALL = 3

member DIRECT

DIRECT = 1

member INVALID

INVALID = 0

member LISTALL

LISTALL = 3

Deprecated
Use ALL instead.

member OID

OID = 1

Deprecated
Use DIRECT instead.

member SYMBOLIC

SYMBOLIC = 2

namespace Remote

namespace Remote {}

enum AUTOTAG_OPTION

const enum AUTOTAG_OPTION {
    DOWNLOAD_TAGS_UNSPECIFIED = 0,
    DOWNLOAD_TAGS_AUTO = 1,
    DOWNLOAD_TAGS_NONE = 2,
    DOWNLOAD_TAGS_ALL = 3,
}

member DOWNLOAD_TAGS_ALL

DOWNLOAD_TAGS_ALL = 3

member DOWNLOAD_TAGS_AUTO

DOWNLOAD_TAGS_AUTO = 1

member DOWNLOAD_TAGS_NONE

DOWNLOAD_TAGS_NONE = 2

member DOWNLOAD_TAGS_UNSPECIFIED

DOWNLOAD_TAGS_UNSPECIFIED = 0

enum COMPLETION_TYPE

const enum COMPLETION_TYPE {
    COMPLETION_DOWNLOAD = 0,
    COMPLETION_INDEXING = 1,
    COMPLETION_ERROR = 2,
}

member COMPLETION_DOWNLOAD

COMPLETION_DOWNLOAD = 0

member COMPLETION_ERROR

COMPLETION_ERROR = 2

member COMPLETION_INDEXING

COMPLETION_INDEXING = 1

namespace Reset

namespace Reset {}

enum TYPE

const enum TYPE {
    SOFT = 1,
    MIXED = 2,
    HARD = 3,
}

member HARD

HARD = 3

member MIXED

MIXED = 2

member SOFT

SOFT = 1

namespace Revparse

namespace Revparse {}

enum MODE

const enum MODE {
    SINGLE = 1,
    RANGE = 2,
    MERGE_BASE = 4,
}

member MERGE_BASE

MERGE_BASE = 4

member RANGE

RANGE = 2

member SINGLE

SINGLE = 1

namespace Revwalk

namespace Revwalk {}

interface HistoryEntry

interface HistoryEntry {}

property commit

commit: Commit;

property newName

newName: string;

property oldName

oldName: string;

property status

status: Diff.DELTA;

enum SORT

const enum SORT {
    NONE = 0,
    TOPOLOGICAL = 1,
    TIME = 2,
    REVERSE = 4,
}

member NONE

NONE = 0

member REVERSE

REVERSE = 4

member TIME

TIME = 2

member TOPOLOGICAL

TOPOLOGICAL = 1

namespace Stash

namespace Stash {}

enum APPLY_FLAGS

const enum APPLY_FLAGS {
    APPLY_DEFAULT = 0,
    APPLY_REINSTATE_INDEX = 1,
}

member APPLY_DEFAULT

APPLY_DEFAULT = 0

member APPLY_REINSTATE_INDEX

APPLY_REINSTATE_INDEX = 1

enum APPLY_PROGRESS

const enum APPLY_PROGRESS {
    NONE = 0,
    LOADING_STASH = 1,
    ANALYZE_INDEX = 2,
    ANALYZE_MODIFIED = 3,
    ANALYZE_UNTRACKED = 4,
    CHECKOUT_UNTRACKED = 5,
    CHECKOUT_MODIFIED = 6,
    DONE = 7,
}

member ANALYZE_INDEX

ANALYZE_INDEX = 2

member ANALYZE_MODIFIED

ANALYZE_MODIFIED = 3

member ANALYZE_UNTRACKED

ANALYZE_UNTRACKED = 4

member CHECKOUT_MODIFIED

CHECKOUT_MODIFIED = 6

member CHECKOUT_UNTRACKED

CHECKOUT_UNTRACKED = 5

member DONE

DONE = 7

member LOADING_STASH

LOADING_STASH = 1

member NONE

NONE = 0

enum FLAGS

const enum FLAGS {
    DEFAULT = 0,
    KEEP_INDEX = 1,
    INCLUDE_UNTRACKED = 2,
    INCLUDE_IGNORED = 4,
}

member DEFAULT

DEFAULT = 0

member INCLUDE_IGNORED

INCLUDE_IGNORED = 4

member INCLUDE_UNTRACKED

INCLUDE_UNTRACKED = 2

member KEEP_INDEX

KEEP_INDEX = 1

namespace Status

namespace Status {}

enum OPT

const enum OPT {
    INCLUDE_UNTRACKED = 1,
    INCLUDE_IGNORED = 2,
    INCLUDE_UNMODIFIED = 4,
    EXCLUDE_SUBMODULES = 8,
    RECURSE_UNTRACKED_DIRS = 16,
    DISABLE_PATHSPEC_MATCH = 32,
    RECURSE_IGNORED_DIRS = 64,
    RENAMES_HEAD_TO_INDEX = 128,
    RENAMES_INDEX_TO_WORKDIR = 256,
    SORT_CASE_SENSITIVELY = 512,
    SORT_CASE_INSENSITIVELY = 1024,
    RENAMES_FROM_REWRITES = 2048,
    NO_REFRESH = 4096,
    UPDATE_INDEX = 8192,
    INCLUDE_UNREADABLE = 16384,
    INCLUDE_UNREADABLE_AS_UNTRACKED = 32768,
}

member DISABLE_PATHSPEC_MATCH

DISABLE_PATHSPEC_MATCH = 32

member EXCLUDE_SUBMODULES

EXCLUDE_SUBMODULES = 8

member INCLUDE_IGNORED

INCLUDE_IGNORED = 2

member INCLUDE_UNMODIFIED

INCLUDE_UNMODIFIED = 4

member INCLUDE_UNREADABLE

INCLUDE_UNREADABLE = 16384

member INCLUDE_UNREADABLE_AS_UNTRACKED

INCLUDE_UNREADABLE_AS_UNTRACKED = 32768

member INCLUDE_UNTRACKED

INCLUDE_UNTRACKED = 1

member NO_REFRESH

NO_REFRESH = 4096

member RECURSE_IGNORED_DIRS

RECURSE_IGNORED_DIRS = 64

member RECURSE_UNTRACKED_DIRS

RECURSE_UNTRACKED_DIRS = 16

member RENAMES_FROM_REWRITES

RENAMES_FROM_REWRITES = 2048

member RENAMES_HEAD_TO_INDEX

RENAMES_HEAD_TO_INDEX = 128

member RENAMES_INDEX_TO_WORKDIR

RENAMES_INDEX_TO_WORKDIR = 256

member SORT_CASE_INSENSITIVELY

SORT_CASE_INSENSITIVELY = 1024

member SORT_CASE_SENSITIVELY

SORT_CASE_SENSITIVELY = 512

member UPDATE_INDEX

UPDATE_INDEX = 8192

enum SHOW

const enum SHOW {
    INDEX_AND_WORKDIR = 0,
    INDEX_ONLY = 1,
    WORKDIR_ONLY = 2,
}

member INDEX_AND_WORKDIR

INDEX_AND_WORKDIR = 0

member INDEX_ONLY

INDEX_ONLY = 1

member WORKDIR_ONLY

WORKDIR_ONLY = 2

enum STATUS

const enum STATUS {
    CURRENT = 0,
    INDEX_NEW = 1,
    INDEX_MODIFIED = 2,
    INDEX_DELETED = 4,
    INDEX_RENAMED = 8,
    INDEX_TYPECHANGE = 16,
    WT_NEW = 128,
    WT_MODIFIED = 256,
    WT_DELETED = 512,
    WT_TYPECHANGE = 1024,
    WT_RENAMED = 2048,
    WT_UNREADABLE = 4096,
    IGNORED = 16384,
    CONFLICTED = 32768,
}

member CONFLICTED

CONFLICTED = 32768

member CURRENT

CURRENT = 0

member IGNORED

IGNORED = 16384

member INDEX_DELETED

INDEX_DELETED = 4

member INDEX_MODIFIED

INDEX_MODIFIED = 2

member INDEX_NEW

INDEX_NEW = 1

member INDEX_RENAMED

INDEX_RENAMED = 8

member INDEX_TYPECHANGE

INDEX_TYPECHANGE = 16

member WT_DELETED

WT_DELETED = 512

member WT_MODIFIED

WT_MODIFIED = 256

member WT_NEW

WT_NEW = 128

member WT_RENAMED

WT_RENAMED = 2048

member WT_TYPECHANGE

WT_TYPECHANGE = 1024

member WT_UNREADABLE

WT_UNREADABLE = 4096

namespace Submodule

namespace Submodule {}

enum IGNORE

const enum IGNORE {
    UNSPECIFIED = -1,
    NONE = 1,
    UNTRACKED = 2,
    DIRTY = 3,
    ALL = 4,
}

member ALL

ALL = 4

member DIRTY

DIRTY = 3

member NONE

NONE = 1

member UNSPECIFIED

UNSPECIFIED = -1

member UNTRACKED

UNTRACKED = 2

enum RECURSE

const enum RECURSE {
    NO = 0,
    YES = 1,
    ONDEMAND = 2,
}

member NO

NO = 0

member ONDEMAND

ONDEMAND = 2

member YES

YES = 1

enum STATUS

const enum STATUS {
    IN_HEAD = 1,
    IN_INDEX = 2,
    IN_CONFIG = 4,
    IN_WD = 8,
    INDEX_ADDED = 16,
    INDEX_DELETED = 32,
    INDEX_MODIFIED = 64,
    WD_UNINITIALIZED = 128,
    WD_ADDED = 256,
    WD_DELETED = 512,
    WD_MODIFIED = 1024,
    WD_INDEX_MODIFIED = 2048,
    WD_WD_MODIFIED = 4096,
    WD_UNTRACKED = 8192,
}

member IN_CONFIG

IN_CONFIG = 4

member IN_HEAD

IN_HEAD = 1

member IN_INDEX

IN_INDEX = 2

member IN_WD

IN_WD = 8

member INDEX_ADDED

INDEX_ADDED = 16

member INDEX_DELETED

INDEX_DELETED = 32

member INDEX_MODIFIED

INDEX_MODIFIED = 64

member WD_ADDED

WD_ADDED = 256

member WD_DELETED

WD_DELETED = 512

member WD_INDEX_MODIFIED

WD_INDEX_MODIFIED = 2048

member WD_MODIFIED

WD_MODIFIED = 1024

member WD_UNINITIALIZED

WD_UNINITIALIZED = 128

member WD_UNTRACKED

WD_UNTRACKED = 8192

member WD_WD_MODIFIED

WD_WD_MODIFIED = 4096

enum UPDATE

const enum UPDATE {
    CHECKOUT = 1,
    REBASE = 2,
    MERGE = 3,
    NONE = 4,
    DEFAULT = 0,
}

member CHECKOUT

CHECKOUT = 1

member DEFAULT

DEFAULT = 0

member MERGE

MERGE = 3

member NONE

NONE = 4

member REBASE

REBASE = 2

namespace Transport

namespace Transport {}

enum FLAGS

const enum FLAGS {
    NONE = 0,
}

member NONE

NONE = 0

namespace Tree

namespace Tree {}

enum WALK_MODE

const enum WALK_MODE {
    WALK_PRE = 0,
    WALK_POST = 1,
}

member WALK_POST

WALK_POST = 1

member WALK_PRE

WALK_PRE = 0

namespace TreeEntry

namespace TreeEntry {}

enum FILEMODE

const enum FILEMODE {
    UNREADABLE = 0,
    TREE = 16384,
    BLOB = 33188,
    EXECUTABLE = 33261,
    LINK = 40960,
    COMMIT = 57344,
}

member BLOB

BLOB = 33188

member COMMIT

COMMIT = 57344

member EXECUTABLE

EXECUTABLE = 33261

member LINK

LINK = 40960

member TREE

TREE = 16384

member UNREADABLE

UNREADABLE = 0

namespace Worktree

namespace Worktree {}

enum PRUNE

const enum PRUNE {
    VALID = 1,
    LOCKED = 2,
    WORKING_TREE = 4,
}

member LOCKED

LOCKED = 2

member VALID

VALID = 1

member WORKING_TREE

WORKING_TREE = 4

Package Files (108)

Dependencies (1)

@types/node

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/nodegit.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/nodegit)

HTML

<a href="https://www.jsdocs.io/package/@types/nodegit"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 month ago.
Package analyzed in 14199 ms.
Missing or incorrect documentation? Open an issue for this package.

@types/nodegit

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Namespaces

Variables

variable Promise

variable version

Functions

function Clone

Classes

class AnnotatedCommit

method fromFetchhead

Parameter repo

Parameter branchName

Parameter remoteUrl

Parameter id

method fromRef

method fromRevspec

method id

method lookup

class Apply

method apply

method toTree

class ApplyOptions

property deltaCb

property hunkCb

property version

class Attr

method addMacro

method cacheFlush

method get

Parameter repo

Parameter flags

Parameter path

Parameter name

Returns

method getMany

Parameter repo

Parameter flags

Parameter path

Parameter numAttr

Parameter names

method value

Parameter attr

Returns

class Blame

method buffer

method file

Parameter repo

Parameter path

Parameter options

method getHunkByIndex

Returns

method getHunkByLine

Returns

method getHunkCount

method initOptions

Parameter opts

Parameter version

class BlameHunk

method finalCommitId

method finalSignature

method finalStartLineNumber

method linesInHunk

method origCommitId

method origPath

method origSignature

method origStartLineNumber

class BlameOptions

property flags

property maxLine

property minLine

property minMatchCharacters

property newestCommit

property oldestCommit