@types/nodegit

Version 0.28.3
Published 2 months ago
101 kB
1 dependency
MIT license

Install

npm i @types/nodegit

yarn add @types/nodegit

pnpm add @types/nodegit

Overview

TypeScript definitions for nodegit

Index

Variables

variable Promise

const Promise: PromiseConstructor;

variable version

const version: string;

Functions

function Clone

Clone: typeof Clone;

Patch repository cloning to automatically coerce objects.

Classes

class AnnotatedCommit

class AnnotatedCommit {}

method free

free: () => void;

method fromFetchhead

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

Parameter repo
repository that contains the given commit
Parameter branchName
name of the (remote) branch
Parameter remoteUrl
url of the remote
Parameter id
the commit object id of the remote branch

method fromRef

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

method fromRevspec

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

method id

id: () => Oid;

method lookup

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

class Apply

class Apply {}

method apply

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

method toTree

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

class ApplyOptions

class ApplyOptions {}

property deltaCb

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

property hunkCb

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

property version

version?: number;

class Attr

class Attr {}

method addMacro

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

method cacheFlush

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

method get

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

Parameter repo
The repository containing the path.
Parameter flags
A combination of GIT_ATTR_CHECK... flags.
Parameter path
The path to check for attributes. Relative paths are interpreted relative to the repo root. The file does not have to exist, but if it does not, then it will be treated as a plain file (not a directory).
Parameter name
The name of the attribute to look up.
Returns
- Output of the value of the attribute. Use the GIT_ATTR_...

method getMany

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

Parameter repo
The repository containing the path.
Parameter flags
A combination of GIT_ATTR_CHECK... flags.
Parameter path
The path to check for attributes. Relative paths are interpreted relative to the repo root. The file does not have to exist, but if it does not, then it will be treated as a plain file (not a directory).
Parameter numAttr
The number of attributes being looked up
Parameter names
An array of num_attr strings containing attribute names.

method value

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

Parameter attr
The attribute
Returns
- the value type for the attribute

class Blame

class Blame {}

method buffer

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

method file

static file: (
    repo: Repository,
    path: string,
    options?: BlameOptions
) => Promise<Blame>;

Retrieve the blame of a file
Parameter repo
Repository that contains the file
Parameter path
to the file to get the blame of
Parameter options
Options for the blame

method free

free: () => void;

method getHunkByIndex

getHunkByIndex: (index: number) => BlameHunk;

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

method getHunkByLine

getHunkByLine: (lineNo: number) => BlameHunk;

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

method getHunkCount

getHunkCount: () => number;

method initOptions

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

Parameter opts
The git_blame_options struct to initialize
Parameter version
Version of struct; pass GIT_BLAME_OPTIONS_VERSION

class BlameHunk

class BlameHunk {}

method finalCommitId

finalCommitId: () => Oid;

method finalSignature

finalSignature: () => Signature;

method finalStartLineNumber

finalStartLineNumber: () => number;

method linesInHunk

linesInHunk: () => number;

method origCommitId

origCommitId: () => Oid;

method origPath

origPath: () => string;

method origSignature

origSignature: () => Signature;

method origStartLineNumber

origStartLineNumber: () => number;

class BlameOptions

class BlameOptions {}

property flags

flags?: number;

property maxLine

maxLine?: number;

property minLine

minLine?: number;

property minMatchCharacters

minMatchCharacters?: number;

property newestCommit

newestCommit?: Oid;

property oldestCommit

oldestCommit?: Oid;

property version

version?: number;

class Blob

class Blob {}

method content

content: () => Buffer;

method createFromBuffer

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

Parameter repo
repository where to blob will be written
Parameter buffer
data to be written into the blob
Parameter len
length of the data
Returns
- return the id of the written blob

method createFromDisk

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

Parameter repo
repository where the blob will be written. this repository can be bare or not
Parameter path
file from which the blob will be created

method createFromStream

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

method createFromWorkdir

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

Parameter repo
repository where the blob will be written. this repository cannot be bare
Parameter relativePath
file from which the blob will be created, relative to the repository's working dir
Returns
- 0 or an error code

method dup

dup: () => Promise<Blob>;

method filemode

filemode: () => number;

method filteredContent

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

method free

free: () => void;

method id

id: () => Oid;

method isBinary

isBinary: () => number;

method lookup

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

method lookupPrefix

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

method owner

owner: () => Repository;

method rawcontent

rawcontent: () => Wrapper;

method rawsize

rawsize: () => number;

method toString

toString: () => string;

class Branch

class Branch {}

method create

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

method createFromAnnotated

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

method delete

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

method isHead

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

method iteratorNew

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

method lookup

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

method move

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

method name

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

method setUpstream

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

method upstream

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

class Buf

class Buf {}

property asize

asize: number;

property ptr

ptr: string;

property size

size: number;

method containsNul

containsNul: () => number;

method free

free: () => void;

method grow

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

method isBinary

isBinary: () => number;

method set

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

class Cert

class Cert {}

property certType

certType: Cert.TYPE;

class CertHostkey

class CertHostkey {}

property hashMd5

hashMd5: string;

property hashSha1

hashSha1: string;

property parent

parent: Cert;

property type

type: Cert.TYPE;

class CertX509

class CertX509 {}

property data

data: Buffer;

property len

len: number;

property parent

parent: Cert;

class Checkout

class Checkout {}

method head

static head: (repo: Repository, options?: CheckoutOptions) => Promise<void>;

Patch head checkout to automatically coerce objects.

method index

static index: (
    repo: Repository,
    The: Index,
    options?: CheckoutOptions
) => Promise<void>;

Patch index checkout to automatically coerce objects.

method initOptions

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

method tree

static tree: (
    repo: Repository,
    treeish: Oid | Tree | Commit | Reference,
    options?: CheckoutOptions
) => Promise<void>;

Patch tree checkout to automatically coerce objects.

class CheckoutOptions

class CheckoutOptions {}

property ancestorLabel

ancestorLabel?: string;

property baseline

baseline?: Tree;

property baselineIndex

baselineIndex?: Index;

property checkoutStrategy

checkoutStrategy?: number;

property dirMode

dirMode?: number;

property disableFilters

disableFilters?: number;

property fileMode

fileMode?: number;

property fileOpenFlags

fileOpenFlags?: number;

property notifyCb

notifyCb?: any;

property notifyFlags

notifyFlags?: number;

property notifyPayload

notifyPayload?: undefined;

property ourLabel

ourLabel?: string;

property paths

paths?: string | Strarray | string[];

property perfdataCb

perfdataCb?: any;

property perfdataPayload

perfdataPayload?: undefined;

property progressCb

progressCb?: any;

property progressPayload

progressPayload?: undefined;

property targetDirectory

targetDirectory?: string;

property theirLabel

theirLabel?: string;

property version

version?: number;

class Cherrypick

class Cherrypick {}

method cherrypick

static cherrypick: (
    repo: Repository,
    commit: Commit,
    options?: CherrypickOptions
) => Promise<void>;

Cherrypick a commit and, changing the index and working directory

method commit

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

Cherrypicks the given commit against "our" commit, producing an index that reflects the result of the cherrypick. The index is not backed by a repo.

method initOptions

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

class CloneOptions

class CloneOptions {}

property bare

bare?: number;

property checkoutBranch

checkoutBranch?: string;

property checkoutOpts

checkoutOpts?: CheckoutOptions;

property fetchOpts

fetchOpts?: FetchOptions;

property local

local?: number;

property remoteCbPayload

remoteCbPayload?: any;

property repositoryCbPayload

repositoryCbPayload?: any;

property version

version?: number;

class Commit

class Commit {}

method amend

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

method amendWithSignature

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

method author

author: () => Signature;

method body

body: () => string;

consists of a summary

method committer

committer: () => Signature;

method create

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

method createV

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

method createWithSignature

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

method date

date: () => Date;

Retrieve the commit time as a Date object.

method dup

dup: () => Promise<Commit>;

method free

free: () => void;

method getDiff

getDiff: (callback?: Function) => Promise<Diff[]>;

Generate an array of diff trees showing changes between this commit and its parent(s).

method getDiffWithOptions

getDiffWithOptions: (options: Object, callback?: Function) => Promise<Diff[]>;

Generate an array of diff trees showing changes between this commit and its parent(s).

method getEntry

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

Retrieve the entry represented by path for this commit. Path must be relative to repository root.

method getParents

getParents: (limit: number, callback?: Function) => Promise<Commit[]>;

Retrieve the commit's parents as commit objects.

method getSignature

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

method getTree

getTree: () => Promise<Tree>;

Get the tree associated with this commit.

method headerField

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

method history

history: () => HistoryEventEmitter;

Walk the history from this commit backwards. An EventEmitter is returned that will emit a "commit" event for each commit in the history, and one "end" event when the walk is completed. Don't forget to call start() on the returned EventEmitter.

method id

id: () => Oid;

method lookup

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

Retrieves the commit pointed to by the oid

method lookupPrefix

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

method message

message: () => string;

method messageEncoding

messageEncoding: () => string;

method messageRaw

messageRaw: () => string;

method nthGenAncestor

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

method owner

owner: () => Repository;

method parent

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

method parentcount

parentcount: () => number;

method parentId

parentId: (n: number) => Oid;

method parents

parents: () => Oid[];

Retrieve the commit's parent shas.

method rawHeader

rawHeader: () => string;

method sha

sha: () => string;

Retrieve the SHA.

method summary

summary: () => string;

method time

time: () => number;

method timeMs

timeMs: () => number;

Retrieve the commit time as a unix timestamp.

method timeOffset

timeOffset: () => number;

method toString

toString: () => string;

The sha of this commit

method tree

tree: (treeOut: Tree) => number;

method treeId

treeId: () => Oid;

class Config

class Config {}

method deleteEntry

deleteEntry: (name: string) => number;

method deleteMultivar

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

method findGlobal

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

method findProgramdata

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

method findSystem

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

method findXdg

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

method getBool

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

method getEntry

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

method getInt32

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

method getInt64

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

method getPath

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

method getStringBuf

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

method lock

lock: (transaction: any) => number;

method openDefault

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

method openOndisk

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

method setBool

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

method setInt32

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

method setInt64

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

method setMultivar

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

method setString

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

method snapshot

snapshot: () => Promise<Config>;

class ConvenientHunk

class ConvenientHunk {}

header: () => string;

Diff header string that represents the context of this hunk of the diff. Something like @@ -169,14 +167,12 @@ ...

method headerLen

headerLen: () => number;

The length of the header

method lines

lines: () => Promise<DiffLine[]>;

The lines in this hunk

method newLines

newLines: () => number;

The number of new lines in the hunk

method newStart

newStart: () => number;

The starting offset of the first new line in the file

method oldLines

oldLines: () => number;

The number of old lines in the hunk

method oldStart

oldStart: () => number;

The starting offset of the first old line in the file

method size

size: () => number;

Number of lines in this hunk

class ConvenientPatch

class ConvenientPatch {}

method hunks

hunks: () => Promise<ConvenientHunk[]>;

The hunks in this patch

method isAdded

isAdded: () => boolean;

Is this an added patch?

method isConflicted

isConflicted: () => boolean;

Is this a conflicted patch?

method isCopied

isCopied: () => boolean;

Is this a copied patch?

method isDeleted

isDeleted: () => boolean;

Is this a deleted patch?

method isIgnored

isIgnored: () => boolean;

Is this an ignored patch?

method isModified

isModified: () => boolean;

Is this an modified patch

method isRenamed

isRenamed: () => boolean;

Is this a renamed patch?

method isTypeChange

isTypeChange: () => boolean;

Is this a type change?

method isUnmodified

isUnmodified: () => boolean;

Is this an unmodified patch?

method isUnreadable

isUnreadable: () => boolean;

Is this an undreadable patch?

method isUntracked

isUntracked: () => boolean;

Is this an untracked patch?

method lineStats

lineStats: () => any;

The line statistics of this patch (#contexts, #added, #deleted)

method newFile

newFile: () => DiffFile;

New attributes of the file

method oldFile

oldFile: () => DiffFile;

Old attributes of the file

method size

size: () => number;

The number of hunks in this patch

method status

status: () => number;

The status of this patch (unmodified, added, deleted)

class Cred

class Cred {}

Deprecated
Replaced with Credential

method defaultNew

static defaultNew: () => Cred;

method free

free: () => void;

method hasUsername

hasUsername: () => number;

method sshKeyFromAgent

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

method sshKeyMemoryNew

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

method sshKeyNew

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

method usernameNew

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

method userpassPlaintextNew

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

class Credential

class Credential {}

method defaultNew

static defaultNew: () => Credential;

method sshKeyFromAgent

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

method sshKeyMemoryNew

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

method sshKeyNew

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

method usernameNew

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

method userpassPlaintextNew

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

class CredUsername

class CredUsername {}

property parent

parent: Cred;

property username

username: string;

class CredUserpassPayload

class CredUserpassPayload {}

property password

password: string;

property username

username: string;

class CvarMap

class CvarMap {}

property cvarType

cvarType: number;

property mapValue

mapValue: number;

property strMatch

strMatch: string;

class DescribeFormatOptions

class DescribeFormatOptions {}

property abbreviatedSize

abbreviatedSize?: number;

property alwaysUseLongFormat

alwaysUseLongFormat?: number;

property dirtySuffix

dirtySuffix?: string;

property version

version?: number;

class DescribeOptions

class DescribeOptions {}

property describeStrategy

describeStrategy?: number;

property maxCandidatesTags

maxCandidatesTags?: number;

property onlyFollowFirstParent

onlyFollowFirstParent?: number;

property pattern

pattern?: string;

property showCommitOidAsFallback

showCommitOidAsFallback?: number;

property version

version?: number;

class Diff

class Diff {}

method blobToBuffer

static blobToBuffer: (
    oldBlob?: Blob,
    oldAsPath?: string,
    buffer?: string,
    bufferAsPath?: string,
    opts?: DiffOptions,
    fileCb?: Function,
    binaryCb?: Function,
    hunkCb?: Function,
    lineCb?: Function
) => Promise<any>;

Directly run a diff between a blob and a buffer.

method findSimilar

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

method fromBuffer

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

method getDelta

getDelta: (idx: number) => DiffDelta;

method getPerfdata

getPerfdata: () => Promise<DiffPerfdata>;

method getStats

getStats: () => Promise<DiffStats>;

Returns
- Structure containg the diff statistics.

method indexToIndex

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

method indexToWorkdir

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

method merge

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

method numDeltas

numDeltas: () => number;

method patches

patches: () => Promise<ConvenientPatch[]>;

Retrieve patches in this difflist

method toBuf

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

method treeToIndex

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

method treeToTree

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

method treeToWorkdir

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

method treeToWorkdirWithIndex

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

class DiffBinary

class DiffBinary {}

property containsData

containsData: DiffBinary.DIFF_BINARY;

property newFile

newFile: DiffBinaryFile;

property oldFile

oldFile: DiffBinaryFile;

class DiffBinaryFile

class DiffBinaryFile {}

property data

data: string;

property datalen

datalen: number;

property inflatedlen

inflatedlen: number;

property type

type: Object.TYPE;

class DiffDelta

class DiffDelta {}

property flags

flags: () => number;

property newFile

newFile: () => DiffFile;

property nfiles

nfiles: () => number;

property oldFile

oldFile: () => DiffFile;

property similarity

similarity: () => number;

property status

status: () => number;

class DiffFile

class DiffFile {}

method flags

flags: () => number;

Returns the file's flags

method id

id: () => Oid;

Returns the file's Oid

method mode

mode: () => number;

Returns the file's mode

method path

path: () => string;

Returns the file's path

method size

size: () => number;

Returns the file's size

class DiffLine

class DiffLine {}

method content

content: () => string;

The relevant line

method contentLen

contentLen: () => number;

method contentOffset

contentOffset: () => number;

method newLineno

newLineno: () => number;

method numLines

numLines: () => number;

method oldLineno

oldLineno: () => number;

method origin

origin: () => number;

method rawContent

rawContent: () => string;

The non utf8 translated text

class DiffPerfdata

class DiffPerfdata {}

property oidCalculations

oidCalculations: number;

property statCalls

statCalls: number;

property version

version: number;

class DiffStats

class DiffStats {}

method deletions

deletions: () => Number;

Returns
- total number of deletions in the diff

method filesChanged

filesChanged: () => Number;

Returns
- total number of files changed in the diff

method insertions

insertions: () => Number;

Returns
- total number of insertions in the diff

method toBuf

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

Parameter format
Formatting option.
Parameter width
Target width for output (only affects GIT_DIFF_STATS_FULL)
Returns
- buffer to store the formatted diff statistics in.

class Error

class Error {}

property klass

klass: number;

property message

message: string;

class Fetch

class Fetch {}

method initOptions

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

class FetchOptions

class FetchOptions {}

property callbacks

callbacks?: RemoteCallbacks;

property customHeaders

customHeaders?: string | Strarray | string[];

property downloadTags

downloadTags?: number;

property proxyOpts

proxyOpts?: any;

property prune

prune?: number;

property updateFetchhead

updateFetchhead?: number;

property version

version?: number;

class Filter

class Filter {}

property attributes

attributes: string;

property stream

stream: Function;

property version

version: number;

method listContains

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

method listLength

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

method listNew

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

method listStreamBlob

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

method listStreamData

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

method listStreamFile

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

method lookup

lookup: (name: string) => Filter;

method register

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

method unregister

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

class Giterr

class Giterr {}

method errClear

static errClear: () => void;

method errLast

static errLast: () => Error;

method errSetOom

static errSetOom: () => void;

method errSetString

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

class Graph

class Graph {}

method aheadBehind

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

method descendantOf

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

class Hashsig

class Hashsig {}

method compare

compare: (b: Hashsig) => number;

method create

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

method createFromFile

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

method free

free: () => void;

class Ignore

class Ignore {}

method addRule

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

method clearInternalRules

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

method pathIsIgnored

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

class Index

class Index {}

method add

add: (sourceEntry: IndexEntry) => number;

method addAll

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

method addByPath

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

method caps

caps: () => number;

method checksum

checksum: () => Oid;

method clear

clear: () => number;

method conflictAdd

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

method conflictCleanup

conflictCleanup: () => number;

method conflictGet

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

method conflictRemove

conflictRemove: (path: string) => number;

method entries

entries: () => IndexEntry[];

method entryCount

entryCount: () => number;

method entryIsConflict

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

method entryStage

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

method findPrefix

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

method getByIndex

getByIndex: (n: number) => IndexEntry;

method getByPath

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

method hasConflicts

hasConflicts: () => boolean;

method open

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

method owner

owner: () => Repository;

method path

path: () => string;

method read

read: (force: number) => number;

method readTree

readTree: (tree: Tree) => number;

method remove

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

method removeAll

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

method removeByPath

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

method removeDirectory

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

method setCaps

setCaps: (caps: number) => number;

method setVersion

setVersion: (version: number) => number;

method updateAll

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

method version

version: () => number;

method write

write: () => Promise<number>;

method writeTree

writeTree: () => Promise<Oid>;

method writeTreeTo

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

class IndexEntry

class IndexEntry {}

property ctime

ctime: IndexTime;

property dev

dev: number;

property fileSize

fileSize: number;

property flags

flags: number;

property flagsExtended

flagsExtended: number;

property gid

gid: number;

property id

id: Oid;

property ino

ino: number;

property mode

mode: number;

property mtime

mtime: IndexTime;

property path

path: string;

property uid

uid: number;

class Indexer

class Indexer {}

method commit

commit: (stats: TransferProgress) => number;

method free

free: () => void;

method hash

hash: () => Oid;

class Libgit2

class Libgit2 {}

method features

static features: () => number;

method init

static init: () => number;

method opts

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

method shutdown

static shutdown: () => number;

method version

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

class Merge

class Merge {}

method base

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

method bases

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

method commits

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

method fileInitInput

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

method initOptions

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

method merge

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

method trees

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

class MergeFileResult

class MergeFileResult {}

property automergeable

automergeable: number;

property len

len: number;

property mode

mode: number;

property path

path: string;

property ptr

ptr: string;

class MergeOptions

class MergeOptions {}

property defaultDriver

defaultDriver?: string;

property fileFavor

fileFavor?: number;

property fileFlags

fileFlags?: number;

property flags

flags?: number;

property recursionLimit

recursionLimit?: number;

property renameThreshold

renameThreshold?: number;

property targetLimit

targetLimit?: number;

property version

version?: number;

class Note

class Note {}

method author

author: () => Signature;

method committer

committer: () => Signature;

method create

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

method foreach

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

method free

free: () => void;

method id

id: () => Oid;

method iteratorNew

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

method message

message: () => string;

method next

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

method read

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

method remove

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

class Object

class Object {}

method dup

dup: () => Promise<Object>;

method free

free: () => void;

method id

id: () => Oid;

method lookup

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

method lookupByPath

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

method lookupPrefix

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

method owner

owner: () => Repository;

method peel

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

method shortId

shortId: () => Promise<Buf>;

method size

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

method string2Type

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

method type

type: () => number;

method type2String

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

method typeisloose

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

class Odb

class Odb {}

method addDiskAlternate

addDiskAlternate: (path: string) => number;

method expandIds

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

method free

free: () => void;

method open

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

method read

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

method write

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

class OdbExpandId

class OdbExpandId {}

property id

id: Oid;

property length

length: number;

property type

type: Object.TYPE;

class OdbObject

class OdbObject {}

method data

data: () => Buffer;

method dup

dup: () => Promise<OdbObject>;

method free

free: () => void;

method id

id: () => Oid;

method size

size: () => number;

method type

type: () => number;

class Oid

class Oid {}

method cmp

cmp: (b: Oid) => number;

method cpy

cpy: () => Oid;

method equal

equal: (b: Oid) => number;

method fromString

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

method iszero

iszero: () => number;

method ncmp

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

method strcmp

strcmp: (str: string) => number;

method streq

streq: (str: string) => number;

method tostrS

tostrS: () => string;

class Oidarray

class Oidarray {}

property count

count: number;

property ids

ids: Oid;

method free

free: () => void;

class Openssl

class Openssl {}

method setLocking

static setLocking: () => number;

class Packbuilder

class Packbuilder {}

method create

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

method free

free: () => void;

method hash

hash: () => Oid;

method insert

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

method insertCommit

insertCommit: (id: Oid) => number;

method insertRecur

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

method insertTree

insertTree: (id: Oid) => number;

method insertWalk

insertWalk: (walk: Revwalk) => number;

method objectCount

objectCount: () => number;

method setThreads

setThreads: (n: number) => number;

method written

written: () => number;

class Pathspec

class Pathspec {}

method create

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

method free

free: () => void;

method matchDiff

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

method matchesPath

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

method matchIndex

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

method matchListDiffEntry

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

method matchListEntry

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

method matchListEntrycount

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

method matchListFailedEntry

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

method matchListFailedEntrycount

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

method matchTree

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

method matchWorkdir

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

class Proxy

class Proxy {}

method initOptions

static initOptions

@types/nodegit

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Namespaces

Variables

variable Promise

variable version

Functions

function Clone

Classes

class AnnotatedCommit

method free

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 free

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