index.d.ts

/* tslint:disable */
/* eslint-disable */

/* auto-generated by NAPI-RS */

export interface CommitOptions {
  updateRef?: string
  /**
   * Signature for author.
   *
   * If not provided, the default signature of the repository will be used.
   * If there is no default signature set for the repository, an error will occur.
   */
  author?: SignaturePayload
  /**
   * Signature for commiter.
   *
   * If not provided, the default signature of the repository will be used.
   * If there is no default signature set for the repository, an error will occur.
   */
  committer?: SignaturePayload
  parents?: Array<string>
}
export const enum DiffFlags {
  /** File(s) treated as binary data. */
  Binary = 1,
  /** File(s) treated as text data. */
  NotBinary = 2,
  /** `id` value is known correct. */
  ValidId = 4,
  /** File exists at this side of the delta. */
  Exists = 8
}
/** Check diff flags contains given flags. */
export declare function diffFlagsContains(source: number, target: number): boolean
/** What type of change is described by a `DiffDelta`? */
export type DeltaType = /** No changes */
'Unmodified' | /** Entry does not exist in an old version */
'Added' | /** Entry does not exist in a new version */
'Deleted' | /** Entry content changed between old and new */
'Modified' | /** Entry was renamed between old and new */
'Renamed' | /** Entry was copied from another old entry */
'Copied' | /** Entry is ignored item in workdir */
'Ignored' | /** Entry is untracked item in workdir */
'Untracked' | /** Type of entry changed between old and new */
'Typechange' | /** Entry is unreadable */
'Unreadable' | /** Entry in the index is conflicted */
'Conflicted';
/** Possible output formats for diff data. */
export type DiffFormat = /** full `git diff` (default) */
'Patch' | /** just the headers of the patch */
'PatchHeader' | /** like `git diff --raw` */
'Raw' | /** like `git diff --name-only` */
'NameOnly' | /** like `git diff --name-status` */
'NameStatus' | /** `git diff` as used by `git patch-id` */
'PatchId';
export interface DiffPrintOptions {
  format?: DiffFormat
}
/** Valid modes for index and tree entries. */
export type FileMode = 'Unreadable' | 'Tree' | 'Blob' | /** Group writable blob. Obsolete mode kept for compatibility reasons */
'BlobGroupWritable' | 'BlobExecutable' | 'Link' | 'Commit';
/** Describing options about how the diff should be executed. */
export interface DiffOptions {
  /** Flag indicating whether the sides of the diff will be reversed. */
  reverse?: boolean
  /** Flag indicating whether ignored files are included. */
  includeIgnored?: boolean
  /** Flag indicating whether ignored directories are traversed deeply or not. */
  recurseIgnoredDirs?: boolean
  /** Flag indicating whether untracked files are in the diff */
  includeUntracked?: boolean
  /**
   * Flag indicating whether untracked directories are traversed deeply or
   * not.
   */
  recurseUntrackedDirs?: boolean
  /** Flag indicating whether unmodified files are in the diff. */
  includeUnmodified?: boolean
  /** If enabled, then Typechange delta records are generated. */
  includeTypechange?: boolean
  /**
   * Event with `includeTypechange`, the tree returned generally shows a
   * deleted blob. This flag correctly labels the tree transitions as a
   * typechange record with the `new_file`'s mode set to tree.
   *
   * Note that the tree SHA will not be available.
   */
  includeTypechangeTrees?: boolean
  /** Flag indicating whether file mode changes are ignored. */
  ignoreFilemode?: boolean
  /** Flag indicating whether all submodules should be treated as unmodified. */
  ignoreSubmodules?: boolean
  /** Flag indicating whether case insensitive filenames should be used. */
  ignoreCase?: boolean
  /**
   * If pathspecs are specified, this flag means that they should be applied
   * as an exact match instead of a fnmatch pattern.
   */
  disablePathspecMatch?: boolean
  /**
   * Disable updating the `binary` flag in delta records. This is useful when
   * iterating over a diff if you don't need hunk and data callbacks and want
   * to avoid having to load a file completely.
   */
  skipBinaryCheck?: boolean
  /**
   * When diff finds an untracked directory, to match the behavior of core
   * Git, it scans the contents for ignored and untracked files. If all
   * contents are ignored, then the directory is ignored; if any contents are
   * not ignored, then the directory is untracked. This is extra work that
   * may not matter in many cases.
   *
   * This flag turns off that scan and immediately labels an untracked
   * directory as untracked (changing the behavior to not match core git).
   */
  enableFastUntrackedDirs?: boolean
  /**
   * When diff finds a file in the working directory with stat information
   * different from the index, but the OID ends up being the same, write the
   * correct stat information into the index. Note: without this flag, diff
   * will always leave the index untouched.
   */
  updateIndex?: boolean
  /** Include unreadable files in the diff */
  includeUnreadable?: boolean
  /** Include unreadable files in the diff as untracked files */
  includeUnreadableAsUntracked?: boolean
  /** Treat all files as text, disabling binary attributes and detection. */
  forceText?: boolean
  /** Treat all files as binary, disabling text diffs */
  forceBinary?: boolean
  /** Ignore all whitespace */
  ignoreWhitespace?: boolean
  /** Ignore changes in the amount of whitespace */
  ignoreWhitespaceChange?: boolean
  /** Ignore whitespace at the end of line */
  ignoreWhitespaceEol?: boolean
  /** Ignore blank lines */
  ignoreBlankLines?: boolean
  /**
   * When generating patch text, include the content of untracked files.
   *
   * This automatically turns on `includeUntracked` but it does not turn on
   * `recurseUntrackedDirs`. Add that flag if you want the content of every
   * single untracked file.
   */
  showUntrackedContent?: boolean
  /**
   * When generating output, include the names of unmodified files if they
   * are included in the `Diff`. Normally these are skipped in the formats
   * that list files (e.g. name-only, name-status, raw). Even with this these
   * will not be included in the patch format.
   */
  showUnmodified?: boolean
  /** Use the "patience diff" algorithm */
  patience?: boolean
  /** Take extra time to find the minimal diff */
  minimal?: boolean
  /**
   * Include the necessary deflate/delta information so that `git-apply` can
   * apply given diff information to binary files.
   */
  showBinary?: boolean
  /**
   * Use a heuristic that takes indentation and whitespace into account
   * which generally can produce better diffs when dealing with ambiguous
   * diff hunks.
   */
  indentHeuristic?: boolean
  /**
   * Set the number of unchanged lines that define the boundary of a hunk
   * (and to display before and after).
   *
   * The default value for this is 3.
   */
  contextLines?: number
  /**
   * Set the maximum number of unchanged lines between hunk boundaries before
   * the hunks will be merged into one.
   *
   * The default value for this is 0.
   */
  interhunkLines?: number
  /** The default value for this is `core.abbrev` or 7 if unset. */
  idAbbrev?: number
  /**
   * Maximum size (in bytes) above which a blob will be marked as binary
   * automatically.
   *
   * A negative value will disable this entirely.
   *
   * The default value for this is 512MB.
   */
  maxSize?: number
  /**
   * The virtual "directory" to prefix old file names with in hunk headers.
   *
   * The default value for this is "a".
   */
  oldPrefix?: string
  /**
   * The virtual "directory" to prefix new file names with in hunk headers.
   *
   * The default value for this is "b".
   */
  newPrefix?: string
  /** Add to the array of paths/fnmatch patterns to constrain the diff. */
  pathspecs?: Array<string>
}
export interface IndexEntry {
  ctime: Date
  mtime: Date
  dev: number
  ino: number
  mode: number
  uid: number
  gid: number
  fileSize: number
  id: string
  flags: number
  flagsExtended: number
  /**
   * The path of this index entry as a byte vector. Regardless of the
   * current platform, the directory separator is an ASCII forward slash
   * (`0x2F`). There are no terminating or internal NUL characters, and no
   * trailing slashes. Most of the time, paths will be valid utf-8 — but
   * not always. For more information on the path storage format, see
   * [these git docs][git-index-docs]. Note that libgit2 will take care of
   * handling the prefix compression mentioned there.
   *
   * [git-index-docs]: https://github.com/git/git/blob/a08a83db2bf27f015bec9a435f6d73e223c21c5e/Documentation/technical/index-format.txt#L107-L124
   */
  path: Buffer
}
export interface IndexOnMatchCallbackArgs {
  /** The path of entry. */
  path: string
  /** The patchspec that matched it. */
  pathspec: string
}
export interface IndexAddAllOptions {
  /**
   * Files that are ignored will be skipped (unlike `addPath`). If a file is
   * already tracked in the index, then it will be updated even if it is
   * ignored. Pass the `force` flag to skip the checking of ignore rules.
   */
  force?: boolean
  /**
   * The `pathspecs` are a list of file names or shell glob patterns that
   * will matched against files in the repository's working directory. Each
   * file that matches will be added to the index (either updating an
   * existing entry or adding a new entry). You can disable glob expansion
   * and force exact matching with the `disablePathspecMatch` flag.
   */
  disablePathspecMatch?: boolean
  /**
   * To emulate `git add -A` and generate an error if the pathspec contains
   * the exact path of an ignored file (when not using `force`), add the
   * `checkPathspec` flag. This checks that each entry in `pathspecs`
   * that is an exact match to a filename on disk is either not ignored or
   * already in the index. If this check fails, the function will return
   * an error.
   */
  checkPathspec?: boolean
  /**
   * If you provide a callback function, it will be invoked on each matching
   * item in the working directory immediately before it is added to /
   * updated in the index. Returning zero will add the item to the index,
   * greater than zero will skip the item, and less than zero will abort the
   * scan an return an error to the caller.
   */
  onMatch?: (args: IndexOnMatchCallbackArgs) => number
}
export type IndexStage = /** Match any index stage. */
'Any' | /** A normal staged file in the index. */
'Normal' | /** The ancestor side of a conflict. */
'Ancestor' | /** The "ours" side of a conflict. */
'Ours' | /** The "theirs" side of a conflict. */
'Theirs';
export interface IndexRemoveOptions {
  stage?: IndexStage
}
export interface IndexRemoveAllOptions {
  /**
   * If you provide a callback function, it will be invoked on each matching
   * item in the index immediately before it is removed. Return 0 to remove
   * the item, > 0 to skip the item, and < 0 to abort the scan.
   */
  onMatch?: (args: IndexOnMatchCallbackArgs) => number
}
export interface IndexUpdateAllOptions {
  /**
   * If you provide a callback function, it will be invoked on each matching
   * item in the index immediately before it is updated (either refreshed or
   * removed depending on working directory state). Return 0 to proceed with
   * updating the item, > 0 to skip the item, and < 0 to abort the scan.
   */
  onMatch?: (args: IndexOnMatchCallbackArgs) => number
}
/** An enumeration all possible kinds objects may have. */
export const enum ObjectType {
  /** Any kind of git object */
  Any = 0,
  /** An object which corresponds to a git commit */
  Commit = 1,
  /** An object which corresponds to a git tree */
  Tree = 2,
  /** An object which corresponds to a git blob */
  Blob = 3,
  /** An object which corresponds to a git tag */
  Tag = 4
}
/**
 * Check if given string is valid Oid.
 *
 * Returns `false` if the string is empty, is longer than 40 hex
 * characters, or contains any non-hex characters.
 */
export declare function isValidOid(value: string): boolean
/** Test if this Oid is all zeros. */
export declare function isZeroOid(value: string): boolean
/** Creates an all zero Oid structure. */
export declare function zeroOid(): string
/**
 * Hashes the provided data as an object of the provided type, and returns
 * an Oid corresponding to the result. This does not store the object
 * inside any object database or repository.
 */
export declare function hashObjectOid(objType: ObjectType, bytes: Buffer): string
/**
 * Hashes the content of the provided file as an object of the provided type,
 * and returns an Oid corresponding to the result. This does not store the object
 * inside any object database or repository.
 */
export declare function hashFileOid(objType: ObjectType, path: string): string
/** An enumeration of all possible kinds of references. */
export type ReferenceType = /** A reference which points at an object id. */
'Direct' | /** A reference which points at another reference. */
'Symbolic';
/**
 * Ensure the reference name is well-formed.
 *
 * Validation is performed as if `ReferenceFormat.AllowOnelevel`
 * was given to `normalizeReferenceName`
 * No normalization is performed, however.
 *
 * @example
 * ```ts
 * import { isValidReferenceName } from 'es-git';
 *
 * console.assert(isValidReferenceName("HEAD"));
 * console.assert(isValidReferenceName("refs/heads/main"));
 *
 * // But:
 * console.assert(!isValidReferenceName("main"));
 * console.assert(!isValidReferenceName("refs/heads/*"));
 * console.assert(!isValidReferenceName("foo//bar"));
 * ```
 */
export declare function isValidReferenceName(refname: string): boolean
/** Options for normalize reference name. */
export const enum ReferenceFormat {
  /** No particular normalization. */
  Normal = 0,
  /**
   * Control whether one-level refname are accepted (i.e., refnames that
   * do not contain multiple `/`-separated components). Those are
   * expected to be written only using uppercase letters and underscore
   * (e.g. `HEAD`, `FETCH_HEAD`).
   * (1 << 0)
   */
  AllowOnelevel = 1,
  /**
   * Interpret the provided name as a reference pattern for a refspec (as
   * used with remote repositories). If this option is enabled, the name
   * is allowed to contain a single `*` in place of a full pathname
   * components (e.g., `foo/*\/bar` but not `foo/bar*`).
   * (1 << 1)
   */
  RefspecPattern = 2,
  /**
   * Interpret the name as part of a refspec in shorthand form so the
   * `AllowOnelevel` naming rules aren't enforced and `main` becomes a
   * valid name.
   * (1 << 2)
   */
  RefspecShorthand = 4
}
/**
 * Normalize reference name and check validity.
 *
 * This will normalize the reference name by collapsing runs of adjacent
 * slashes between name components into a single slash. It also validates
 * the name according to the following rules:
 *
 * 1. If `ReferenceFormat.AllowOnelevel` is given, the name may
 *    contain only capital letters and underscores, and must begin and end
 *    with a letter. (e.g. "HEAD", "ORIG_HEAD").
 * 2. The flag `ReferenceFormat.RefspecShorthand` has an effect
 *    only when combined with `ReferenceFormat.AllowOnelevel`. If
 *    it is given, "shorthand" branch names (i.e. those not prefixed by
 *    `refs/`, but consisting of a single word without `/` separators)
 *    become valid. For example, "main" would be accepted.
 * 3. If `ReferenceFormat.RefspecPattern` is given, the name may
 *    contain a single `*` in place of a full pathname component (e.g.
 *    `foo/*\/bar`, `foo/bar*`).
 * 4. Names prefixed with "refs/" can be almost anything. You must avoid
 *    the characters '~', '^', ':', '\\', '?', '[', and '*', and the
 *    sequences ".." and "@{" which have special meaning to revparse.
 *
 * If the reference passes validation, it is returned in normalized form,
 * otherwise an `null` is returned.
 *
 * @example
 * ```ts
 * import { normalizeReferenceName, ReferenceFormat } from 'es-git';
 *
 * console.assert(
 *   normalizeReferenceName('foo//bar"),
 *   'foo/bar'
 * );
 * console.assert(
 *   normalizeReferenceName(
 *     'HEAD',
 *     ReferenceFormat.AllowOnelevel
 *   ),
 *   'HEAD'
 * );
 * console.assert(
 *   normalizeReferenceName(
 *     'refs/heads/*',
 *     ReferenceFormat.RefspecPattern
 *   ),
 *   'refs/heads/*'
 * );
 * console.assert(
 *   normalizeReferenceName(
 *     'main',
 *     ReferenceFormat.AllowOnelevel | ReferenceFormat.RefspecShorthand
 *   ),
 *   'main'
 * );
 * ```
 */
export declare function normalizeReferenceName(refname: string, format?: number | undefined | null): string | null
export interface RenameReferenceOptions {
  /**
   * If the force flag is not enabled, and there's already a reference with
   * the given name, the renaming will fail.
   */
  force?: boolean
  logMessage?: string
}
/** An enumeration of the possible directions for a remote. */
export type Direction = 'Fetch' | 'Push';
/**
 * A data object to represent a git [refspec][1].
 *
 * Refspecs are currently mainly accessed/created through a `Remote`.
 *
 * [1]: https://git-scm.com/book/en/Git-Internals-The-Refspec
 */
export interface Refspec {
  direction: Direction
  src: string
  dst: string
  force: boolean
}
/** Options which can be specified to various fetch operations. */
export interface ProxyOptions {
  /**
   * Try to auto-detect the proxy from the git configuration.
   *
   * Note that this will override `url` specified before.
   */
  auto?: boolean
  /**
   * Specify the exact URL of the proxy to use.
   *
   * Note that this will override `auto` specified before.
   */
  url?: string
}
/** Configuration for how pruning is done on a fetch. */
export type FetchPrune = /** Use the setting from the configuration */
'Unspecified' | /** Force pruning on */
'On' | /** Force pruning off */
'Off';
export type Credential = /** Create a "default" credential usable for Negotiate mechanisms like NTLM or Kerberos authentication.*/
{
 type: 'Default';
} | /** Create a new ssh key credential object used for querying an ssh-agent.
The username specified is the username to authenticate.*/
{
 type: 'SSHKeyFromAgent';
 username?: string;
} | /** Create a new passphrase-protected ssh key credential object.*/
{
 type: 'SSHKeyFromPath';
 username?: string;
 publicKeyPath?: string;
 privateKeyPath: string;
 passphrase?: string;
} | /** Create a new ssh key credential object reading the keys from memory.*/
{
 type: 'SSHKey';
 username?: string;
 publicKey?: string;
 privateKey: string;
 passphrase?: string;
} | /** Create a new plain-text username and password credential object.*/
{
 type: 'Plain';
 username?: string;
 password: string;
};
/** Automatic tag following options. */
export type AutotagOption = /** Use the setting from the remote's configuration */
'Unspecified' | /** Ask the server for tags pointing to objects we're already downloading */
'Auto' | /** Don't ask for any tags beyond the refspecs */
'None' | /** Ask for all the tags */
'All';
/**
 * Remote redirection settings; whether redirects to another host are
 * permitted.
 *
 * By default, git will follow a redirect on the initial request
 * (`/info/refs`), but not subsequent requests.
 */
export type RemoteRedirect = /** Do not follow any off-site redirects at any stage of the fetch or push. */
'None' | /**
 * Allow off-site redirects only upon the initial request. This is the
 * default.
 */
'Initial' | /** Allow redirects at any stage in the fetch or push. */
'All';
/** Options which can be specified to various fetch operations. */
export interface FetchOptions {
  credential?: Credential
  /** Set the proxy options to use for the fetch operation. */
  proxy?: ProxyOptions
  /** Set whether to perform a prune after the fetch. */
  prune?: FetchPrune
  /**
   * Set fetch depth, a value less or equal to 0 is interpreted as pull
   * everything (effectively the same as not declaring a limit depth).
   */
  depth?: number
  /**
   * Set how to behave regarding tags on the remote, such as auto-downloading
   * tags for objects we're downloading or downloading all of them.
   *
   * The default is to auto-follow tags.
   */
  downloadTags?: AutotagOption
  /**
   * Set remote redirection settings; whether redirects to another host are
   * permitted.
   *
   * By default, git will follow a redirect on the initial request
   * (`/info/refs`), but not subsequent requests.
   */
  followRedirects?: RemoteRedirect
  /** Set extra headers for this fetch operation. */
  customHeaders?: Array<string>
}
/** Options to control the behavior of a git push. */
export interface PushOptions {
  credential?: Credential
  /** Set the proxy options to use for the push operation. */
  proxy?: ProxyOptions
  /**
   * If the transport being used to push to the remote requires the creation
   * of a pack file, this controls the number of worker threads used by the
   * packbuilder when creating that pack file to be sent to the remote.
   *
   * If set to 0, the packbuilder will auto-detect the number of threads to
   * create, and the default value is 1.
   */
  pbParallelism?: number
  /**
   * Set remote redirection settings; whether redirects to another host are
   * permitted.
   *
   * By default, git will follow a redirect on the initial request
   * (`/info/refs`), but not subsequent requests.
   */
  followRedirects?: RemoteRedirect
  /** Set extra headers for this push operation. */
  customHeaders?: Array<string>
  /** Set "push options" to deliver to the remote. */
  remoteOptions?: Array<string>
}
export interface CreateRemoteOptions {
  fetchRefspec?: string
}
export interface FetchRemoteOptions {
  fetch?: FetchOptions
  reflogMsg?: string
}
export interface PruneOptions {
  credential?: Credential
}
/** A listing of the possible states that a repository can be in. */
export type RepositoryState = 'Clean' | 'Merge' | 'Revert' | 'RevertSequence' | 'CherryPick' | 'CherryPickSequence' | 'Bisect' | 'Rebase' | 'RebaseInteractive' | 'RebaseMerge' | 'ApplyMailbox' | 'ApplyMailboxOrRebase';
/** Mode options for `RepositoryInitOptions`. */
export const enum RepositoryInitMode {
  /** Use permissions configured by umask (default) */
  SharedUnmask = 0,
  /**
   * Use `--shared=group` behavior, chmod'ing the new repo to be
   * group writable and "g+sx" for sticky group assignment.
   */
  SharedGroup = 1533,
  /** Use `--shared=all` behavior, adding world readability. */
  SharedAll = 1535
}
export interface RepositoryInitOptions {
  /**
   * Create a bare repository with no working directory.
   *
   * Defaults to `false`.
   */
  bare?: boolean
  /**
   * Return an error if the repository path appears to already be a git
   * repository.
   *
   * Defaults to `false`.
   */
  noReinit?: boolean
  /**
   * Normally a '/.git/' will be appended to the repo path for non-bare repos
   * (if it is not already there), but passing this flag prevents that
   * behavior.
   *
   * Defaults to `false`.
   */
  noDotgitDir?: boolean
  /**
   * Make the repo path (and workdir path) as needed. The ".git" directory
   * will always be created regardless of this flag.
   *
   * Defaults to `true`.
   */
  mkdir?: boolean
  /**
   * Make the repo path (and workdir path) as needed. The ".git" directory
   * will always be created regardless of this flag.
   *
   * Defaults to `true`.
   */
  mkpath?: boolean
  /** Set to one of the `RepositoryInit` constants, or a custom value. */
  mode?: number
  /**
   * Enable or disable using external templates.
   *
   * If enabled, then the `template_path` option will be queried first, then
   * `init.templatedir` from the global config, and finally
   * `/usr/share/git-core-templates` will be used (if it exists).
   *
   * Defaults to `true`.
   */
  externalTemplate?: boolean
  /**
   * When the `externalTemplate` option is set, this is the first location
   * to check for the template directory.
   *
   * If this is not configured, then the default locations will be searched
   * instead.
   */
  templatePath?: string
  /**
   * The path to the working directory.
   *
   * If this is a relative path it will be evaluated relative to the repo
   * path. If this is not the "natural" working directory, a .git gitlink
   * file will be created here linking to the repo path.
   */
  workdirPath?: string
  /**
   * If set, this will be used to initialize the "description" file in the
   * repository instead of using the template content.
   */
  description?: string
  /**
   * The name of the head to point HEAD at.
   *
   * If not configured, this will be taken from your git configuration.
   * If this begins with `refs/` it will be used verbatim;
   * otherwise `refs/heads/` will be prefixed.
   */
  initialHead?: string
  /**
   * If set, then after the rest of the repository initialization is
   * completed an `origin` remote will be added pointing to this URL.
   */
  originUrl?: string
}
/** Options which can be used to configure how a repository is initialized. */
export interface RepositoryOpenOptions {
  /**
   * If flags contains `RepositoryOpenFlags.NoSearch`, the path must point
   * directly to a repository; otherwise, this may point to a subdirectory
   * of a repository, and `open` will search up through parent
   * directories.
   *
   * If flags contains `RepositoryOpenFlags.CrossFS`, the search through parent
   * directories will not cross a filesystem boundary (detected when the
   * stat st_dev field changes).
   *
   * If flags contains `RepositoryOpenFlags.Bare`, force opening the repository as
   * bare even if it isn't, ignoring any working directory, and defer
   * loading the repository configuration for performance.
   *
   * If flags contains `RepositoryOpenFlags.NoDotgit`, don't try appending
   * `/.git` to `path`.
   *
   * If flags contains `RepositoryOpenFlags.FromEnv`, `open` will ignore
   * other flags and `ceilingDirs`, and respect the same environment
   * variables git does. Note, however, that `path` overrides `$GIT_DIR`.
   */
  flags: number
  /**
   * ceiling_dirs specifies a list of paths that the search through parent
   * directories will stop before entering.
   */
  ceilingDirs?: Array<string>
}
/** Flags for opening repository. */
export const enum RepositoryOpenFlags {
  /** Only open the specified path; don't walk upward searching. */
  NoSearch = 1,
  /** Search across filesystem boundaries. */
  CrossFS = 2,
  /** Force opening as a bare repository, and defer loading its config. */
  Bare = 4,
  /** Don't try appending `/.git` to the specified repository path. */
  NoDotGit = 8,
  /** Respect environment variables like `$GIT_DIR`. */
  FromEnv = 16
}
export interface RepositoryCloneOptions {
  /**
   * Indicate whether the repository will be cloned as a bare repository or
   * not.
   */
  bare?: boolean
  /**
   * Specify the name of the branch to check out after the clone.
   *
   * If not specified, the remote's default branch will be used.
   */
  branch?: string
  /**
   * Clone a remote repository, initialize and update its submodules
   * recursively.
   *
   * This is similar to `git clone --recursive`.
   */
  recursive?: boolean
  /** Options which control the fetch. */
  fetch?: FetchOptions
}
/** Creates a new repository in the specified folder. */
export declare function initRepository(path: string, options?: RepositoryInitOptions | undefined | null, signal?: AbortSignal | undefined | null): Promise<Repository>
/** Attempt to open an already-existing repository at `path`. */
export declare function openRepository(path: string, options?: RepositoryOpenOptions | undefined | null, signal?: AbortSignal | undefined | null): Promise<Repository>
/**
 * Attempt to open an already-existing repository at or above `path`.
 *
 * This starts at `path` and looks up the filesystem hierarchy
 * until it finds a repository.
 */
export declare function discoverRepository(path: string, signal?: AbortSignal | undefined | null): Promise<Repository>
/**
 * Clone a remote repository.
 *
 * This will use the options configured so far to clone the specified URL
 * into the specified local path.
 */
export declare function cloneRepository(url: string, path: string, options?: RepositoryCloneOptions | undefined | null, signal?: AbortSignal | undefined | null): Promise<Repository>
/** Flags for the revparse. */
export const enum RevparseMode {
  /** The spec targeted a single object */
  Single = 1,
  /** The spec targeted a range of commits */
  Range = 2,
  /** The spec used the `...` operator, which invokes special semantics. */
  MergeBase = 4
}
/** Check revparse mode contains specific flags. */
export declare function revparseModeContains(source: number, target: number): boolean
/** A revspec represents a range of revisions within a repository. */
export interface Revspec {
  /** Access the `from` range of this revspec. */
  from?: string
  /** Access the `to` range of this revspec. */
  to?: string
  /** Returns the intent of the revspec. */
  mode: number
}
/** Orderings that may be specified for Revwalk iteration. */
export const enum RevwalkSort {
  /**
   * Sort the repository contents in no particular ordering.
   *
   * This sorting is arbitrary, implementation-specific, and subject to
   * change at any time. This is the default sorting for new walkers.
   */
  None = 0,
  /**
   * Sort the repository contents in topological order (children before
   * parents).
   *
   * This sorting mode can be combined with time sorting.
   */
  Topological = 1,
  /**
   * Sort the repository contents by commit time.
   *
   * This sorting mode can be combined with topological sorting.
   */
  Time = 2,
  /**
   * Iterate through the repository contents in reverse order.
   *
   * This sorting mode can be combined with any others.
   */
  Reverse = 4
}
/**
 * A Signature is used to indicate authorship of various actions throughout the
 * library.
 *
 * Signatures contain a name, email, and timestamp.
 */
export interface Signature {
  /** Name on the signature. */
  name: string
  /** Email on the signature. */
  email: string
  /** Time in seconds, from epoch */
  timestamp: number
}
export interface SignatureTimeOptions {
  /** Time in seconds, from epoch */
  timestamp: number
  /** Timezone offset, in minutes */
  offset?: number
}
/** Create a new action signature. */
export declare function createSignature(name: string, email: string, timeOptions?: SignatureTimeOptions | undefined | null): Signature
export interface SignaturePayload {
  /** Name on the signature. */
  name: string
  /** Email on the signature. */
  email: string
  timeOptions?: SignatureTimeOptions
}
/**
 * Determine whether a tag name is valid, meaning that (when prefixed with refs/tags/) that
 * it is a valid reference name, and that any additional tag name restrictions are imposed
 * (eg, it cannot start with a -).
 */
export declare function isValidTagName(tagName: string): boolean
export interface CreateTagOptions {
  /**
   * Signature for tagger.
   *
   * If not provided, default signature of repository will be used.
   * If there is no default signature set for the repository, an error will occur.
   */
  tagger?: SignaturePayload
  force?: boolean
}
export interface CreateAnnotationTagOptions {
  /**
   * Signature for tagger.
   *
   * If not provided, default signature of repository will be used.
   * If there is no default signature set for the repository, an error will occur.
   */
  tagger?: SignaturePayload
}
export interface CreateLightweightTagOptions {
  force?: boolean
}
/**
 * A binary indicator of whether a tree walk should be performed in pre-order
 * or post-order.
 */
export type TreeWalkMode = 'PreOrder' | 'PostOrder';
/**
 * A class to represent a git [blob][1].
 *
 * [1]: https://git-scm.com/book/en/Git-Internals-Git-Objects
 */
export declare class Blob {
  /** Get the id (SHA1) of a repository blob. */
  id(): string
  /** Determine if the blob content is most certainly binary or not. */
  isBinary(): boolean
  /** Get the content of this blob. */
  content(): Uint8Array
  /** Get the size in bytes of the contents of this blob. */
  size(): bigint
}
/**
 * A class to represent a git commit.
 * @hideconstructor
 */
export declare class Commit {
  /** Get the id (SHA1) of a repository commit */
  id(): string
  /** Get the author of this commit. */
  author(): Signature
  /** Get the committer of this commit. */
  committer(): Signature
  /**
   * Get the full message of a commit.
   *
   * The returned message will be slightly prettified by removing any
   * potential leading newlines.
   *
   * Throws error if the message is not valid utf-8.
   */
  message(): string
  /**
   * Get the short "summary" of the git commit message.
   *
   * The returned message is the summary of the commit, comprising the first
   * paragraph of the message with whitespace trimmed and squashed.
   *
   * Throws error if the summary is not valid utf-8.
   */
  summary(): string | null
  /**
   * Get the long "body" of the git commit message.
   *
   * The returned message is the body of the commit, comprising everything
   * but the first paragraph of the message. Leading and trailing whitespaces
   * are trimmed.
   *
   * Throws error if the summary is not valid utf-8.
   */
  body(): string | null
  /** Get the commit time (i.e. committer time) of a commit. */
  time(): Date
  /** Get the tree pointed to by a commit. */
  tree(): Tree
  /** Casts this Commit to be usable as an `GitObject`. */
  asObject(): GitObject
}
/**
 * The diff object that contains all individual file deltas.
 *
 * This is an opaque structure which will be allocated by one of the diff
 * generator functions on the `Repository` class (e.g. `diffTreeToTree`
 * or other `diff*` functions).
 *
 * @hideconstructor
 */
export declare class Diff {
  /**
   * Merge one diff into another.
   *
   * This merges items from the "from" list into the "self" list.  The
   * resulting diff will have all items that appear in either list.
   * If an item appears in both lists, then it will be "merged" to appear
   * as if the old version was from the "onto" list and the new version
   * is from the "from" list (with the exception that if the item has a
   * pending DELETE in the middle, then it will show as deleted).
   */
  merge(diff: Diff): void
  /** Returns an iterator over the deltas in this diff. */
  deltas(): Deltas
  /** Check if deltas are sorted case sensitively or insensitively. */
  isSortedIcase(): boolean
  /** Accumulate diff statistics for all patches. */
  stats(): DiffStats
  /** Iterate over a diff generating formatted text output. */
  print(options?: DiffPrintOptions | undefined | null): string
}
/**
 * A class describing a hunk of a diff.
 *
 * @hideconstructor
 */
export declare class DiffStats {
  /** Get the total number of files changed in a diff. */
  get filesChanged(): bigint
  /** Get the total number of insertions in a diff */
  get insertions(): bigint
  /** Get the total number of deletions in a diff */
  get deletions(): bigint
}
/**
 * An iterator over the diffs in a delta.
 *
 * @hideconstructor
 */
export declare class Deltas {
  [Symbol.iterator](): Iterator<DiffDelta, void, void>
}
/**
 * Description of changes to one entry.
 *
 * @hideconstructor
 */
export declare class DiffDelta {
  /**
   * Returns the flags on the delta.
   *
   * For more information, see `DiffFlags`'s documentation.
   */
  flags(): number
  /** Returns the number of files in this delta. */
  numFiles(): number
  /** Returns the status of this entry. */
  status(): DeltaType
  /**
   * Return the file which represents the "from" side of the diff.
   *
   * What side this means depends on the function that was used to generate
   * the diff and will be documented on the function itself.
   */
  oldFile(): DiffFile
  /**
   * Return the file which represents the "to" side of the diff.
   *
   * What side this means depends on the function that was used to generate
   * the diff and will be documented on the function itself.
   */
  newFile(): DiffFile
}
/**
 * Description of one side of a delta.
 *
 * Although this is called a "file" it could represent a file, a symbolic
 * link, a submodule commit id, or even a tree (although that only happens if
 * you are tracking type changes or ignored/untracked directories).
 *
 * @hideconstructor
 */
export declare class DiffFile {
  /**
   * Returns the Oid of this item.
   *
   * If this entry represents an absent side of a diff (e.g. the `oldFile`
   * of a `Added` delta), then the oid returned will be zeroes.
   */
  id(): string
  /**
   * Returns the path of the entry relative to the working directory of the
   * repository.
   */
  path(): string | null
  /** Returns the size of this entry, in bytes. */
  size(): bigint
  /** Returns `true` if file(s) are treated as binary data. */
  isBinary(): boolean
  /** Returns `true` if `id` value is known correct. */
  isValidId(): boolean
  /** Returns `true` if file exists at this side of the delta. */
  exists(): boolean
  /** Returns file mode. */
  mode(): FileMode
}
/**
 * A class to represent a git [index][1].
 * @hideconstructor
 *
 * [1]: https://git-scm.com/book/en/Git-Internals-Git-Objects
 */
export declare class Index {
  /**
   * Get index on-disk version.
   *
   * Valid return values are 2, 3, or 4. If 3 is returned, an index
   * with version 2 may be written instead, if the extension data in
   * version 3 is not necessary.
   */
  version(): number
  /**
   * Set index on-disk version.
   *
   * Valid values are 2, 3, or 4. If 2 is given, git_index_write may
   * write an index with version 3 instead, if necessary to accurately
   * represent the index.
   */
  setVersion(version: number): void
  /** Get one of the entries in the index by its path. */
  getByPath(path: string, stage?: IndexStage | undefined | null): IndexEntry | null
  /**
   * Add or update an index entry from a file on disk.
   *
   * The file path must be relative to the repository's working folder and
   * must be readable.
   *
   * This method will fail in bare index instances.
   *
   * This forces the file to be added to the index, not looking at gitignore
   * rules.
   *
   * If this file currently is the result of a merge conflict, this file will
   * no longer be marked as conflicting. The data about the conflict will be
   * moved to the "resolve undo" (REUC) section.
   */
  addPath(path: string): void
  /**
   * Add or update index entries matching files in the working directory.
   *
   * This method will fail in bare index instances.
   *
   * The `pathspecs` are a list of file names or shell glob patterns that
   * will matched against files in the repository's working directory. Each
   * file that matches will be added to the index (either updating an
   * existing entry or adding a new entry).
   *
   * @example
   *
   * Emulate `git add *`:
   *
   * ```ts
   * import { openRepository } from 'es-git';
   *
   * const repo = await openRepository('.');
   * const index = repo.index();
   * index.addAll(['*']);
   * index.write();
   * ```
   */
  addAll(pathspecs: Array<string>, options?: IndexAddAllOptions | undefined | null): void
  /**
   * Update the contents of an existing index object in memory by reading
   * from the hard disk.
   *
   * If force is true, this performs a "hard" read that discards in-memory
   * changes and always reloads the on-disk index data. If there is no
   * on-disk version, the index will be cleared.
   *
   * If force is false, this does a "soft" read that reloads the index data
   * from disk only if it has changed since the last time it was loaded.
   * Purely in-memory index data will be untouched. Be aware: if there are
   * changes on disk, unwritten in-memory changes are discarded.
   */
  read(force?: boolean | undefined | null): void
  /**
   * Write an existing index object from memory back to disk using an atomic
   * file lock.
   */
  write(): void
  /**
   * Write the index as a tree.
   *
   * This method will scan the index and write a representation of its
   * current state back to disk; it recursively creates tree objects for each
   * of the subtrees stored in the index, but only returns the OID of the
   * root tree. This is the OID that can be used e.g. to create a commit.
   *
   * The index instance cannot be bare, and needs to be associated to an
   * existing repository.
   *
   * The index must not contain any file in conflict.
   */
  writeTree(): string
  /**
   * Remove an index entry corresponding to a file on disk.
   *
   * The file path must be relative to the repository's working folder. It
   * may exist.
   *
   * If this file currently is the result of a merge conflict, this file will
   * no longer be marked as conflicting. The data about the conflict will be
   * moved to the "resolve undo" (REUC) section.
   */
  removePath(path: string, options?: IndexRemoveOptions | undefined | null): void
  /** Remove all matching index entries. */
  removeAll(pathspecs: Array<string>, options?: IndexRemoveAllOptions | undefined | null): void
  /**
   * Update all index entries to match the working directory.
   *
   * This method will fail in bare index instances.
   *
   * This scans the existing index entries and synchronizes them with the
   * working directory, deleting them if the corresponding working directory
   * file no longer exists otherwise updating the information (including
   * adding the latest version of file to the ODB if needed).
   */
  updateAll(pathspecs: Array<string>, options?: IndexUpdateAllOptions | undefined | null): void
  /** Get the count of entries currently in the index. */
  count(): number
  /** Return `true` is there is no entry in the index. */
  isEmpty(): boolean
  /**
   * Get the full path to the index file on disk.
   *
   * Returns `None` if this is an in-memory index.
   */
  path(): string | null
  /**
   * Does this index have conflicts?
   *
   * Returns `true` if the index contains conflicts, `false` if it does not.
   */
  hasConflicts(): boolean
  /** Get an iterator over the entries in this index. */
  entries(): IndexEntries
}
/**
 * An iterator over the entries in an index.
 *
 * @hideconstructor
 */
export declare class IndexEntries {
  [Symbol.iterator](): Iterator<IndexEntry, void, void>
}
/**
 * A class to represent a git [object][1].
 * @hideconstructor
 *
 * [1]: https://git-scm.com/book/en/Git-Internals-Git-Objects
 */
export declare class GitObject {
  /** Get the id (SHA1) of a repository object. */
  id(): string
  /**
   * Get the object type of object.
   *
   * If the type is unknown, then `null` is returned.
   */
  type(): ObjectType | null
  /**
   * Recursively peel an object until an object of the specified type is met.
   *
   * If you pass `Any` as the target type, then the object will be
   * peeled until the type changes (e.g. a tag will be chased until the
   * referenced object is no longer a tag).
   */
  peel(objType: ObjectType): GitObject
  /** Recursively peel an object until a commit is found. */
  peelToCommit(): Commit
  /** Recursively peel an object until a blob is found. */
  peelToBlob(): Blob
  /**
   * Attempt to view this object as a commit.
   *
   * Returns `null` if the object is not actually a commit.
   */
  asCommit(): Commit | null
}
/**
 * A class to represent a git [reference][1].
 * @hideconstructor
 *
 * [1]: https://git-scm.com/book/en/Git-Internals-Git-References
 */
export declare class Reference {
  /**
   * Delete an existing reference.
   *
   * This method works for both direct and symbolic references. The reference
   * will be immediately removed on disk.
   *
   * This function will return an error if the reference has changed from the
   * time it was looked up.
   */
  delete(): void
  /** Check if a reference is a local branch. */
  isBranch(): boolean
  /** Check if a reference is a note. */
  isNote(): boolean
  /** Check if a reference is a remote tracking branch. */
  isRemote(): boolean
  /** Check if a reference is a tag. */
  isTag(): boolean
  /**
   * Get the reference type of a reference.
   *
   * If the type is unknown, then `null` is returned.
   */
  type(): ReferenceType | null
  /**
   * Get the full name of a reference.
   *
   * Throws error if the name is not valid utf-8.
   */
  name(): string
  /**
   * Get the full shorthand of a reference.
   *
   * This will transform the reference name into a name "human-readable"
   * version. If no shortname is appropriate, it will return the full name.
   *
   * Throws error if the shorthand is not valid utf-8.
   */
  shorthand(): string
  /**
   * Get the OID pointed to by a direct reference.
   *
   * Only available if the reference is direct (i.e. an object id reference,
   * not a symbolic one).
   */
  target(): string | null
  /**
   * Return the peeled OID target of this reference.
   *
   * This peeled OID only applies to direct references that point to a hard.
   */
  targetPeel(): string | null
  /**
   * Peel a reference to a tree.
   *
   * This method recursively peels the reference until it reaches
   * a tree.
   */
  peelToTree(): Tree
  /**
   * Get full name to the reference pointed to by a symbolic reference.
   *
   * Only available if the reference is symbolic.
   */
  symbolicTarget(): string | null
  /**
   * Resolve a symbolic reference to a direct reference.
   *
   * This method iteratively peels a symbolic reference until it resolves to
   * a direct reference to an OID.
   *
   * If a direct reference is passed as an argument, a copy of that
   * reference is returned.
   */
  resolve(): Reference
  /**
   * Rename an existing reference.
   *
   * This method works for both direct and symbolic references.
   *
   * If the force flag is not enabled, and there's already a reference with
   * the given name, the renaming will fail.
   */
  rename(newName: string, options?: RenameReferenceOptions | undefined | null): Reference
}
/**
 * A class representing a [remote][1] of a git repository.
 * @hideconstructor
 *
 * [1]: https://git-scm.com/book/en/Git-Basics-Working-with-Remotes
 */
export declare class Remote {
  /**
   * Get the remote's name.
   *
   * Returns `null` if this remote has not yet been named, and
   * throws error if the name is not valid utf-8.
   */
  name(): string | null
  /**
   * Get the remote's URL.
   *
   * Throws error if the URL is not valid utf-8.
   */
  url(): string
  /**
   * Get the remote's URL.
   *
   * Returns `null` if push url not exists, and
   * throws error if the URL is not valid utf-8.
   */
  pushurl(): string | null
  /**
   * List all refspecs.
   *
   * Filter refspec if has not valid `src` or `dst` with utf-8.
   */
  refspecs(): Array<Refspec>
  /**
   * Download new data and update tips.
   *
   * Convenience function to connect to a remote, download the data, disconnect and update the remote-tracking branches.
   */
  fetch(refspecs: Array<string>, options?: FetchRemoteOptions | undefined | null, signal?: AbortSignal | undefined | null): Promise<void>
  /**
   * Perform a push.
   *
   * Perform all the steps for a push.
   * If no refspecs are passed, then the configured refspecs will be used.
   */
  push(refspecs: Array<string>, options?: PushOptions | undefined | null, signal?: AbortSignal | undefined | null): Promise<void>
  /** Prune tracking refs that are no longer present on remote. */
  prune(options?: PruneOptions | undefined | null, signal?: AbortSignal | undefined | null): Promise<void>
  /**
   * Get the remote’s default branch.
   *
   * The `fetch` operation from the remote is also performed.
   */
  defaultBranch(signal?: AbortSignal | undefined | null): Promise<string>
}
/**
 * An owned git repository, representing all state associated with the
 * underlying filesystem.
 *
 * This class corresponds to a git repository in libgit2.
 *
 * @hideconstructor
 */
export declare class Repository {
  /**
   * Lookup a reference to one of the commits in a repository.
   *
   * Returns `null` if the commit does not exist.
   */
  findCommit(oid: string): Commit | null
  /** Lookup a reference to one of the commits in a repository. */
  getCommit(oid: string): Commit
  /**
   * Create new commit in the repository.
   *
   * If the `updateRef` is not `null`, name of the reference that will be
   * updated to point to this commit. If the reference is not direct, it will
   * be resolved to a direct reference. Use "HEAD" to update the HEAD of the
   * current branch and make it point to this commit. If the reference
   * doesn't exist yet, it will be created. If it does exist, the first
   * parent must be the tip of this branch.
   */
  commit(tree: Tree, message: string, options?: CommitOptions | undefined | null): string
  /**
   * Create a diff with the difference between two tree objects.
   *
   * This is equivalent to `git diff <old-tree> <new-tree>`.
   *
   * The first tree will be used for the "oldFile" side of the delta and the
   * second tree will be used for the "newFile" side of the delta. You can
   * pass `null` to indicate an empty tree, although it is an error to pass
   * `null` for both the `oldTree` and `newTree`.
   */
  diffTreeToTree(oldTree?: Tree | undefined | null, newTree?: Tree | undefined | null, options?: DiffOptions | undefined | null): Diff
  /**
   * Create a diff between two index objects.
   *
   * The first index will be used for the "oldFile" side of the delta, and
   * the second index will be used for the "newFile" side of the delta.
   */
  diffIndexToIndex(oldIndex: Index, newIndex: Index, options?: DiffOptions | undefined | null): Diff
  /**
   * Create a diff between the repository index and the workdir directory.
   *
   * This matches the `git diff` command.  See the note below on
   * `diffTreeToWorkdir` for a discussion of the difference between
   * `git diff` and `git diff HEAD` and how to emulate a `git diff <treeish>`
   * using libgit2.
   *
   * The index will be used for the "oldFile" side of the delta, and the
   * working directory will be used for the "newFile" side of the delta.
   *
   * If you pass `null` for the index, then the existing index of the `repo`
   * will be used. In this case, the index will be refreshed from disk
   * (if it has changed) before the diff is generated.
   */
  diffIndexToWorkdir(index?: Index | undefined | null, options?: DiffOptions | undefined | null): Diff
  /**
   * Create a diff between a tree and the working directory.
   *
   * The tree you provide will be used for the "oldFile" side of the delta,
   * and the working directory will be used for the "newFile" side.
   *
   * This is not the same as `git diff <treeish>` or `git diff-index <treeish>`.
   * Those commands use information from the index, whereas this
   * function strictly returns the differences between the tree and the files
   * in the working directory, regardless of the state of the index. Use
   * `diffTreeToWorkdirWithIndex` to emulate those commands.
   *
   * To see difference between this and `diffTreeToWorkdirWithIndex`,
   * consider the example of a staged file deletion where the file has then
   * been put back into the working dir and further modified. The
   * tree-to-workdir diff for that file is 'modified', but `git diff` would
   * show status 'deleted' since there is a staged delete.
   *
   * If `null` is passed for `tree`, then an empty tree is used.
   */
  diffTreeToWorkdir(oldTree?: Tree | undefined | null, options?: DiffOptions | undefined | null): Diff
  /**
   * Create a diff between a tree and the working directory using index data
   * to account for staged deletes, tracked files, etc.
   *
   * This emulates `git diff <tree>` by diffing the tree to the index and
   * the index to the working directory and blending the results into a
   * single diff that includes staged deleted, etc.
   */
  diffTreeToWorkdirWithIndex(oldTree?: Tree | undefined | null, options?: DiffOptions | undefined | null): Diff
  /**
   * Get the Index file for this repository.
   *
   * If a custom index has not been set, the default index for the repository
   * will be returned (the one located in `.git/index`).
   */
  index(): Index
  /**
   * Lookup a reference to one of the objects in a repository.
   *
   * Returns `null` if the object does not exist.
   */
  findObject(oid: string): GitObject | null
  /**
   * Lookup a reference to one of the objects in a repository.
   *
   * Throws error if the object does not exist.
   */
  getObject(oid: string): GitObject
  /**
   * Lookup a reference to one of the objects in a repository.
   *
   * Returns `null` if the reference does not exist.
   */
  findReference(name: string): Reference | null
  /**
   * Lookup a reference to one of the objects in a repository.
   *
   * Throws error if the reference does not exist.
   */
  getReference(name: string): Reference
  /** List all remotes for a given repository */
  remoteNames(): Array<string>
  /**
   * Get remote from repository.
   *
   * Throws error if remote does not exist.
   */
  getRemote(name: string): Remote
  /**
   * Find remote from repository.
   *
   * Returns `null` if remote does not exist.
   */
  findRemote(name: string): Remote | null
  /** Add a remote with the default fetch refspec to the repository’s configuration. */
  createRemote(name: string, url: string, options?: CreateRemoteOptions | undefined | null): Remote
  /** Tests whether this repository is a bare repository or not. */
  isBare(): boolean
  /** Tests whether this repository is a shallow clone. */
  isShallow(): boolean
  /** Tests whether this repository is a worktree. */
  isWorktree(): boolean
  /** Tests whether this repository is empty. */
  isEmpty(): boolean
  /**
   * Returns the path to the `.git` folder for normal repositories or the
   * repository itself for bare repositories.
   */
  path(): string
  /** Returns the current state of this repository. */
  state(): RepositoryState
  /**
   * Get the path of the working directory for this repository.
   *
   * If this repository is bare, then `null` is returned.
   */
  workdir(): string | null
  /** Retrieve and resolve the reference pointed at by HEAD. */
  head(): Reference
  /**
   * Make the repository HEAD point to the specified reference.
   *
   * If the provided reference points to a tree or a blob, the HEAD is
   * unaltered and an error is returned.
   *
   * If the provided reference points to a branch, the HEAD will point to
   * that branch, staying attached, or become attached if it isn't yet. If
   * the branch doesn't exist yet, no error will be returned. The HEAD will
   * then be attached to an unborn branch.
   *
   * Otherwise, the HEAD will be detached and will directly point to the
   * commit.
   */
  setHead(refname: string): void
  /**
   * Execute a rev-parse operation against the `spec` listed.
   *
   * The resulting revision specification is returned, or an error is
   * returned if one occurs.
   */
  revparse(spec: string): Revspec
  /** Find a single object, as specified by a revision string. */
  revparseSingle(spec: string): string
  /** Create a revwalk that can be used to traverse the commit graph. */
  revwalk(): Revwalk
  /**
   * Lookup a tag object by prefix hash from the repository.
   *
   * Returns `null` if tag does not exist.
   */
  findTag(oid: string): Tag | null
  /** Lookup a tag object by prefix hash from the repository. */
  getTag(oid: string): Tag
  /**
   * Get a list with all the tags in the repository.
   *
   * An optional fnmatch pattern can also be specified.
   */
  tagNames(pattern?: string | undefined | null): Array<string>
  /**
   * Iterate over all tags calling `callback` on each.
   * The callback is provided the tag id and name.
   */
  tagForeach(callback: (oid: string, name: string) => boolean): void
  /**
   * Delete an existing tag reference.
   *
   * The tag name will be checked for validity, see `isValidTagName` for some rules
   * about valid names.
   */
  deleteTag(name: string): void
  /**
   * Create a new tag in the repository from an object.
   *
   * A new reference will also be created pointing to this tag object. If
   * `force` is true and a reference already exists with the given name,
   * it'll be replaced.
   *
   * The message will not be cleaned up.
   *
   * The tag name will be checked for validity. You must avoid the characters
   * '~', '^', ':', ' \ ', '?', '[', and '*', and the sequences ".." and " @
   * {" which have special meaning to revparse.
   */
  createTag(name: string, target: GitObject, message: string, options?: CreateTagOptions | undefined | null): string
  /**
   * Create a new tag in the repository from an object without creating a reference.
   *
   * The message will not be cleaned up.
   *
   * The tag name will be checked for validity. You must avoid the characters
   * '~', '^', ':', ' \ ', '?', '[', and '*', and the sequences ".." and " @
   * {" which have special meaning to revparse.
   */
  createAnnotationTag(name: string, target: GitObject, message: string, options?: CreateAnnotationTagOptions | undefined | null): string
  /**
   * Create a new lightweight tag pointing at a target object.
   *
   * A new direct reference will be created pointing to this target object.
   * If force is true and a reference already exists with the given name,
   * it'll be replaced.
   */
  createLightweightTag(name: string, target: GitObject, options?: CreateLightweightTagOptions | undefined | null): string
  /** Lookup a reference to one of the objects in a repository. */
  getTree(oid: string): Tree
  /**
   * Lookup a reference to one of the objects in a repository.
   *
   * If it does not exist, returns `null`.
   */
  findTree(oid: string): Tree | null
}
/**
 * A revwalk allows traversal of the commit graph defined by including one or
 * more leaves and excluding one or more roots.
 *
 * @hideconstructor
 */
export declare class Revwalk {
  [Symbol.iterator](): Iterator<string, void, void>
  /**
   * Reset a revwalk to allow re-configuring it.
   *
   * The revwalk is automatically reset when iteration of its commits
   * completes.
   */
  reset(): this
  /** Set the order in which commits are visited. */
  setSorting(sort: number): this
  /**
   * Simplify the history by first-parent.
   *
   * No parents other than the first for each commit will be enqueued.
   */
  simplifyFirstParent(): this
  /**
   * Mark a commit to start traversal from.
   *
   * The given OID must belong to a commitish on the walked repository.
   *
   * The given commit will be used as one of the roots when starting the
   * revision walk. At least one commit must be pushed onto the walker before
   * a walk can be started.
   */
  push(oid: string): this
  /**
   * Push the repository's HEAD.
   *
   * For more information, see `push`.
   */
  pushHead(): this
  /**
   * Push matching references.
   *
   * The OIDs pointed to by the references that match the given glob pattern
   * will be pushed to the revision walker.
   *
   * A leading 'refs/' is implied if not present as well as a trailing `/ \
   * *` if the glob lacks '?', ' \ *' or '['.
   *
   * Any references matching this glob which do not point to a commitish
   * will be ignored.
   */
  pushGlob(glob: string): this
  /**
   * Push and hide the respective endpoints of the given range.
   *
   * The range should be of the form `<commit>..<commit>` where each
   * `<commit>` is in the form accepted by `revparseSingle`. The left-hand
   * commit will be hidden and the right-hand commit pushed.
   */
  pushRange(range: string): this
  /**
   * Push the OID pointed to by a reference.
   *
   * The reference must point to a commitish.
   */
  pushRef(reference: string): this
  /** Mark a commit as not of interest to this revwalk. */
  hide(oid: string): this
  /**
   * Hide the repository's HEAD.
   *
   * For more information, see `hide`.
   */
  hideHead(): this
  /**
   * Hide matching references.
   *
   * The OIDs pointed to by the references that match the given glob pattern
   * and their ancestors will be hidden from the output on the revision walk.
   *
   * A leading 'refs/' is implied if not present as well as a trailing `/ \
   * *` if the glob lacks '?', ' \ *' or '['.
   *
   * Any references matching this glob which do not point to a commitish
   * will be ignored.
   */
  hideGlob(glob: string): this
  /**
   * Hide the OID pointed to by a reference.
   *
   * The reference must point to a commitish.
   */
  hideRef(reference: string): this
}
/**
 * A class to represent a git [tag][1].
 * @hideconstructor
 *
 * [1]: https://git-scm.com/book/en/Git-Basics-Tagging
 */
export declare class Tag {
  /** Get the id (SHA1) of a repository tag. */
  id(): string
  /**
   * Get the message of a tag.
   *
   * Returns `null` if there is no message or if it is not valid utf8.
   */
  message(): string | null
  /**
   * Get the name of a tag.
   *
   * Throws error if it is not valid utf8.
   */
  name(): string
  /** Recursively peel a tag until a non tag git_object is found. */
  peel(): GitObject
  /**
   * Get the tagger (author) of a tag.
   *
   * If the author is unspecified, then `null` is returned.
   */
  tagger(): Signature | null
  /**
   * Get the tagged object of a tag.
   *
   * This method performs a repository lookup for the given object and
   * returns it.
   */
  target(): GitObject
  /** Get the OID of the tagged object of a tag. */
  targetId(): string
  /** Get the ObjectType of the tagged object of a tag. */
  targetType(): ObjectType | null
}
/**
 * A class to represent a git [tree][1].
 * @hideconstructor
 *
 * [1]: https://git-scm.com/book/en/Git-Internals-Git-Objects
 */
export declare class Tree {
  /** Get the id (SHA1) of a repository object. */
  id(): string
  /** Get the number of entries listed in this tree. */
  len(): bigint
  /** Return `true` if there is no entry. */
  isEmpty(): boolean
  /** Returns an iterator over the entries in this tree. */
  iter(): TreeIter
  /**
   * Traverse the entries in a tree and its subtrees in post or pre-order.
   * The callback function will be run on each node of the tree that's
   * walked. The return code of this function will determine how the walk
   * continues.
   *
   * libgit2 requires that the callback be an integer, where 0 indicates a
   * successful visit, 1 skips the node, and -1 aborts the traversal completely.
   * See [libgit2 documentation][1] for more information.
   *
   * [1]: https://libgit2.org/libgit2/#HEAD/group/tree/git_tree_walk
   */
  walk(mode: TreeWalkMode, callback: (entry: TreeEntry) => number): void
  /** Lookup a tree entry by SHA value. */
  getId(id: string): TreeEntry | null
  /** Lookup a tree entry by its position in the tree. */
  get(index: number): TreeEntry | null
  /** Lookup a tree entry by its filename. */
  getName(filename: string): TreeEntry | null
  /**
   * Retrieve a tree entry contained in a tree or in any of its subtrees,
   * given its relative path.
   */
  getPath(path: string): TreeEntry | null
  /** Casts this Tree to be usable as an `GitObject`. */
  asObject(): GitObject
}
/**
 * An iterator over the entries in a tree.
 *
 * @hideconstructor
 */
export declare class TreeIter {
  [Symbol.iterator](): Iterator<TreeEntry, void, void>
}
/**
 * A class representing an entry inside of a tree. An entry is borrowed
 * from a tree.
 *
 * @hideconstructor
 */
export declare class TreeEntry {
  /** Get the id of the object pointed by the entry. */
  id(): string
  /**
   * Get the filename of a tree entry.
   *
   * Throws error if the name is not valid utf-8.
   */
  name(): string
  /** Get the type of the object pointed by the entry. */
  type(): ObjectType | null
  /** Get the UNIX file attributes of a tree entry. */
  filemode(): number
  /** Convert a tree entry to the object it points to. */
  toObject(repo: Repository): GitObject
}