@shopify/cli-kit 0.33.6 → 1.0.1

package/dist/index.d.ts

@@ -1,9 +1,11 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
 import { Readable } from 'stream';
-import { Writable } from 'node:stream';
+import { ChildProcess } from 'node:child_process';
+import { Readable as Readable$1, Writable } from 'node:stream';
 import path$1 from 'path';
 import * as fs from 'fs';
+import { SpawnOptions } from 'child_process';
 import { platform } from 'node:process';
 import { RequestOptions } from 'http';
 
@@ -1461,6 +1463,180 @@ declare namespace error$1 {
   };
 }
 
+interface ExecaReturnBase<StdoutStderrType> {
+	/**
+	The file and arguments that were run, for logging purposes.
+
+	This is not escaped and should not be executed directly as a process, including using `execa()` or `execaCommand()`.
+	*/
+	command: string;
+
+	/**
+	Same as `command` but escaped.
+
+	This is meant to be copy and pasted into a shell, for debugging purposes.
+	Since the escaping is fairly basic, this should not be executed directly as a process, including using `execa()` or `execaCommand()`.
+	*/
+	escapedCommand: string;
+
+	/**
+	The numeric exit code of the process that was run.
+	*/
+	exitCode: number;
+
+	/**
+	The output of the process on stdout.
+	*/
+	stdout: StdoutStderrType;
+
+	/**
+	The output of the process on stderr.
+	*/
+	stderr: StdoutStderrType;
+
+	/**
+	Whether the process failed to run.
+	*/
+	failed: boolean;
+
+	/**
+	Whether the process timed out.
+	*/
+	timedOut: boolean;
+
+	/**
+	Whether the process was killed.
+	*/
+	killed: boolean;
+
+	/**
+	The name of the signal that was used to terminate the process. For example, `SIGFPE`.
+
+	If a signal terminated the process, this property is defined and included in the error message. Otherwise it is `undefined`.
+	*/
+	signal?: string;
+
+	/**
+	A human-friendly description of the signal that was used to terminate the process. For example, `Floating point arithmetic error`.
+
+	If a signal terminated the process, this property is defined and included in the error message. Otherwise it is `undefined`. It is also `undefined` when the signal is very uncommon which should seldomly happen.
+	*/
+	signalDescription?: string;
+}
+
+interface ExecaSyncReturnValue<StdoutErrorType = string>
+	extends ExecaReturnBase<StdoutErrorType> {
+}
+
+/**
+Result of a child process execution. On success this is a plain object. On failure this is also an `Error` instance.
+
+The child process fails when:
+- its exit code is not `0`
+- it was killed with a signal
+- timing out
+- being canceled
+- there's not enough memory or there are already too many child processes
+*/
+interface ExecaReturnValue<StdoutErrorType = string>
+	extends ExecaSyncReturnValue<StdoutErrorType> {
+	/**
+	The output of the process with `stdout` and `stderr` interleaved.
+
+	This is `undefined` if either:
+	- the `all` option is `false` (default value)
+	- `execaSync()` was used
+	*/
+	all?: StdoutErrorType;
+
+	/**
+	Whether the process was canceled.
+
+	You can cancel the spawned process using the [`signal`](https://github.com/sindresorhus/execa#signal-1) option.
+	*/
+	isCanceled: boolean;
+}
+
+interface ExecaSyncError<StdoutErrorType = string>
+	extends Error,
+	ExecaReturnBase<StdoutErrorType> {
+	/**
+	Error message when the child process failed to run. In addition to the underlying error message, it also contains some information related to why the child process errored.
+
+	The child process stderr then stdout are appended to the end, separated with newlines and not interleaved.
+	*/
+	message: string;
+
+	/**
+	This is the same as the `message` property except it does not include the child process stdout/stderr.
+	*/
+	shortMessage: string;
+
+	/**
+	Original error message. This is the same as the `message` property except it includes neither the child process stdout/stderr nor some additional information added by Execa.
+
+	This is `undefined` unless the child process exited due to an `error` event or a timeout.
+	*/
+	originalMessage?: string;
+}
+
+interface ExecaError<StdoutErrorType = string>
+	extends ExecaSyncError<StdoutErrorType> {
+	/**
+	The output of the process with `stdout` and `stderr` interleaved.
+
+	This is `undefined` if either:
+	- the `all` option is `false` (default value)
+	- `execaSync()` was used
+	*/
+	all?: StdoutErrorType;
+
+	/**
+	Whether the process was canceled.
+	*/
+	isCanceled: boolean;
+}
+
+interface KillOptions {
+	/**
+	Milliseconds to wait for the child process to terminate before sending `SIGKILL`.
+
+	Can be disabled with `false`.
+
+	@default 5000
+	*/
+	forceKillAfterTimeout?: number | false;
+}
+
+interface ExecaChildPromise<StdoutErrorType> {
+	/**
+	Stream combining/interleaving [`stdout`](https://nodejs.org/api/child_process.html#child_process_subprocess_stdout) and [`stderr`](https://nodejs.org/api/child_process.html#child_process_subprocess_stderr).
+
+	This is `undefined` if either:
+		- the `all` option is `false` (the default value)
+		- both `stdout` and `stderr` options are set to [`'inherit'`, `'ipc'`, `Stream` or `integer`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio)
+	*/
+	all?: Readable$1;
+
+	catch<ResultType = never>(
+		onRejected?: (reason: ExecaError<StdoutErrorType>) => ResultType | PromiseLike<ResultType>
+	): Promise<ExecaReturnValue<StdoutErrorType> | ResultType>;
+
+	/**
+	Same as the original [`child_process#kill()`](https://nodejs.org/api/child_process.html#child_process_subprocess_kill_signal), except if `signal` is `SIGTERM` (the default value) and the child process is not terminated after 5 seconds, force it by sending `SIGKILL`.
+	*/
+	kill(signal?: string, options?: KillOptions): void;
+
+	/**
+	Similar to [`childProcess.kill()`](https://nodejs.org/api/child_process.html#child_process_subprocess_kill_signal). This is preferred when cancelling the child process execution as the error is more descriptive and [`childProcessResult.isCanceled`](#iscanceled) is set to `true`.
+	*/
+	cancel(): void;
+}
+
+type ExecaChildProcess<StdoutErrorType = string> = ChildProcess &
+ExecaChildPromise<StdoutErrorType> &
+Promise<ExecaReturnValue<StdoutErrorType>>;
+
 interface ExecOptions {
     cwd?: string;
     stdout?: Writable;
@@ -1474,7 +1650,7 @@ declare const open: (url: string) => Promise<void>;
  * @returns A promise that resolves with the aggregatted stdout of the command.
  */
 declare const captureOutput: (command: string, args: string[]) => Promise<string>;
-declare const exec: (command: string, args: string[], options?: ExecOptions | undefined) => Promise<void>;
+declare const exec: (command: string, args: string[], options?: ExecOptions | undefined) => ExecaChildProcess<string>;
 
 type system_ExecOptions = ExecOptions;
 declare const system_open: typeof open;
@@ -1510,18 +1686,18 @@ declare namespace template {
   };
 }
 
-interface Options$4 {
+interface Options$5 {
     splitRegexp?: RegExp | RegExp[];
     stripRegexp?: RegExp | RegExp[];
     delimiter?: string;
     transform?: (part: string, index: number, parts: string[]) => string;
 }
 
-declare function camelCase(input: string, options?: Options$4): string;
+declare function camelCase(input: string, options?: Options$5): string;
 
-declare function paramCase(input: string, options?: Options$4): string;
+declare function paramCase(input: string, options?: Options$5): string;
 
-declare function snakeCase(input: string, options?: Options$4): string;
+declare function snakeCase(input: string, options?: Options$5): string;
 
 /** Returns a random string */
 declare function randomHex(size: number): string;
@@ -1557,7 +1733,7 @@ declare const format: typeof path$1.format;
 declare const basename: typeof path$1.basename;
 declare const parse: typeof path$1.parse;
 
-interface Options$3 {
+interface Options$4 {
 	/**
 	The current working directory.
 
@@ -1590,7 +1766,7 @@ declare const findUpStop: unique symbol;
 
 type Match = string | typeof findUpStop | undefined;
 
-interface Options$2 extends Options$3 {
+interface Options$3 extends Options$4 {
 	/**
 	The path to the directory to stop the search before reaching root if there were no matches before the `stopAt` directory.
 
@@ -1626,7 +1802,7 @@ console.log(await findUp(['rainbow.png', 'unicorn.png']));
 //=> '/Users/sindresorhus/unicorn.png'
 ```
 */
-declare function findUp(name: string | readonly string[], options?: Options$2): Promise<string | undefined>;
+declare function findUp(name: string | readonly string[], options?: Options$3): Promise<string | undefined>;
 
 /**
 Find a file or directory by walking up parent directories.
@@ -1646,7 +1822,7 @@ console.log(await findUp(async directory => {
 //=> '/Users/sindresorhus'
 ```
 */
-declare function findUp(matcher: (directory: string) => (Match | Promise<Match>), options?: Options$2): Promise<string | undefined>;
+declare function findUp(matcher: (directory: string) => (Match | Promise<Match>), options?: Options$3): Promise<string | undefined>;
 
 declare type ErrnoException$1 = NodeJS.ErrnoException;
 
@@ -1701,7 +1877,7 @@ declare type Entry = Entry$1;
 declare type Pattern = string;
 declare type FileSystemAdapter = FileSystemAdapter$1;
 
-declare type Options$1 = {
+declare type Options$2 = {
     /**
      * Return the absolute path for entries.
      *
@@ -1846,25 +2022,25 @@ declare type Task = {
 };
 
 declare type EntryObjectModePredicate = {
-    [TKey in keyof Pick<Options$1, 'objectMode'>]-?: true;
+    [TKey in keyof Pick<Options$2, 'objectMode'>]-?: true;
 };
 declare type EntryStatsPredicate = {
-    [TKey in keyof Pick<Options$1, 'stats'>]-?: true;
+    [TKey in keyof Pick<Options$2, 'stats'>]-?: true;
 };
 declare type EntryObjectPredicate = EntryObjectModePredicate | EntryStatsPredicate;
-declare function FastGlob(source: Pattern | Pattern[], options: Options$1 & EntryObjectPredicate): Promise<Entry[]>;
-declare function FastGlob(source: Pattern | Pattern[], options?: Options$1): Promise<string[]>;
+declare function FastGlob(source: Pattern | Pattern[], options: Options$2 & EntryObjectPredicate): Promise<Entry[]>;
+declare function FastGlob(source: Pattern | Pattern[], options?: Options$2): Promise<string[]>;
 declare namespace FastGlob {
-    type Options = Options$1;
+    type Options = Options$2;
     type Entry = Entry;
     type Task = Task;
     type Pattern = Pattern;
     type FileSystemAdapter = FileSystemAdapter;
-    function sync(source: Pattern | Pattern[], options: Options$1 & EntryObjectPredicate): Entry[];
-    function sync(source: Pattern | Pattern[], options?: Options$1): string[];
-    function stream(source: Pattern | Pattern[], options?: Options$1): NodeJS.ReadableStream;
-    function generateTasks(source: Pattern | Pattern[], options?: Options$1): Task[];
-    function isDynamicPattern(source: Pattern, options?: Options$1): boolean;
+    function sync(source: Pattern | Pattern[], options: Options$2 & EntryObjectPredicate): Entry[];
+    function sync(source: Pattern | Pattern[], options?: Options$2): string[];
+    function stream(source: Pattern | Pattern[], options?: Options$2): NodeJS.ReadableStream;
+    function generateTasks(source: Pattern | Pattern[], options?: Options$2): Task[];
+    function isDynamicPattern(source: Pattern, options?: Options$2): boolean;
     function escapePath(source: Pattern): Pattern;
 }
 
@@ -1925,7 +2101,10 @@ declare function copy(from: string, to: string): Promise<void>;
 declare function write(path: string, data: string): Promise<void>;
 declare function append(path: string, data: string): Promise<void>;
 declare function mkdir(path: string): Promise<void>;
-declare function rmdir(path: string): Promise<void>;
+declare function remove(path: string): Promise<void>;
+declare function rmdir(path: string, { force }?: {
+    force?: boolean;
+}): Promise<void>;
 declare function mkTmpDir(): Promise<string>;
 declare function isDirectory(path: string): Promise<boolean>;
 /**
@@ -1961,6 +2140,7 @@ declare const file_copy: typeof copy;
 declare const file_write: typeof write;
 declare const file_append: typeof append;
 declare const file_mkdir: typeof mkdir;
+declare const file_remove: typeof remove;
 declare const file_rmdir: typeof rmdir;
 declare const file_mkTmpDir: typeof mkTmpDir;
 declare const file_isDirectory: typeof isDirectory;
@@ -1976,6 +2156,7 @@ declare namespace file {
     file_write as write,
     file_append as append,
     file_mkdir as mkdir,
+    file_remove as remove,
     file_rmdir as rmdir,
     file_mkTmpDir as mkTmpDir,
     file_isDirectory as isDirectory,
@@ -1986,10 +2167,1413 @@ declare namespace file {
   };
 }
 
+declare const EMPTY_COMMANDS: [];
+declare type EmptyTask = {
+    commands: typeof EMPTY_COMMANDS;
+    format: 'empty';
+    parser: EmptyTaskParser;
+    onError?: undefined;
+};
+
+declare type TaskResponseFormat = Buffer | string;
+interface TaskParser<INPUT extends TaskResponseFormat, RESPONSE> {
+    (stdOut: INPUT, stdErr: INPUT): RESPONSE;
+}
+interface EmptyTaskParser {
+    (executor: SimpleGitExecutor): void;
+}
+interface SimpleGitTaskConfiguration<RESPONSE, FORMAT, INPUT extends TaskResponseFormat> {
+    commands: string[];
+    format: FORMAT;
+    parser: TaskParser<INPUT, RESPONSE>;
+    onError?: (result: GitExecutorResult, error: Error, done: (result: Buffer | Buffer[]) => void, fail: (error: string | Error) => void) => void;
+}
+declare type StringTask<R> = SimpleGitTaskConfiguration<R, 'utf-8', string>;
+declare type BufferTask<R> = SimpleGitTaskConfiguration<R, 'buffer', Buffer>;
+declare type RunnableTask<R> = StringTask<R> | BufferTask<R>;
+declare type SimpleGitTask<R> = RunnableTask<R> | EmptyTask;
+
+/**
+ * The `GitError` is thrown when the underlying `git` process throws a
+ * fatal exception (eg an `ENOENT` exception when attempting to use a
+ * non-writable directory as the root for your repo), and acts as the
+ * base class for more specific errors thrown by the parsing of the
+ * git response or errors in the configuration of the task about to
+ * be run.
+ *
+ * When an exception is thrown, pending tasks in the same instance will
+ * not be executed. The recommended way to run a series of tasks that
+ * can independently fail without needing to prevent future tasks from
+ * running is to catch them individually:
+ *
+ * ```typescript
+ import { gitP, SimpleGit, GitError, PullResult } from 'simple-git';
+
+ function catchTask (e: GitError) {
+   return e.
+ }
+
+ const git = gitP(repoWorkingDir);
+ const pulled: PullResult | GitError = await git.pull().catch(catchTask);
+ const pushed: string | GitError = await git.pushTags().catch(catchTask);
+ ```
+ */
+declare class GitError extends Error {
+    task?: EmptyTask | StringTask<any> | BufferTask<any> | undefined;
+    constructor(task?: EmptyTask | StringTask<any> | BufferTask<any> | undefined, message?: string);
+}
+
+/**
+ * The node-style callback to a task accepts either two arguments with the first as a null
+ * and the second as the data, or just one argument which is an error.
+ */
+declare type SimpleGitTaskCallback<T = string, E extends GitError = GitError> = (err: E | null, data: T) => void;
+/**
+ * The event data emitted to the progress handler whenever progress detail is received.
+ */
+interface SimpleGitProgressEvent {
+    /** The underlying method called - push, pull etc */
+    method: string;
+    /** The type of progress being reported, note that any one task may emit many stages - for example `git clone` emits both `receiving` and `resolving` */
+    stage: 'compressing' | 'counting' | 'receiving' | 'resolving' | 'unknown' | 'writing' | string;
+    /** The percent progressed as a number 0 - 100 */
+    progress: number;
+    /** The number of items processed so far */
+    processed: number;
+    /** The total number of items to be processed */
+    total: number;
+}
+
+/**
+ * Most tasks accept custom options as an array of strings as well as the
+ * options object. Unless the task is explicitly documented as such, the
+ * tasks will not accept both formats at the same time, preferring whichever
+ * appears last in the arguments.
+ */
+declare type TaskOptions<O extends Options$1 = Options$1> = string[] | O;
+/**
+ * Options supplied in most tasks as an optional trailing object
+ */
+declare type OptionsValues = null | string | number;
+declare type Options$1 = Record<string, OptionsValues>;
+declare type OptionFlags<FLAGS extends string, VALUE = null> = Partial<Record<FLAGS, VALUE>>;
+/**
+ * A function called by the executor immediately after creating a child
+ * process. Allows the calling application to implement custom handling of
+ * the incoming stream of data from the `git`.
+ */
+declare type outputHandler = (command: string, stdout: NodeJS.ReadableStream, stderr: NodeJS.ReadableStream, args: string[]) => void;
+/**
+ * Environment variables to be passed into the child process.
+ */
+declare type GitExecutorEnv = NodeJS.ProcessEnv | undefined;
+/**
+ * Public interface of the Executor
+ */
+interface SimpleGitExecutor {
+    env: GitExecutorEnv;
+    outputHandler?: outputHandler;
+    binary: string;
+    cwd: string;
+    chain(): SimpleGitExecutor;
+    push<R>(task: SimpleGitTask<R>): Promise<R>;
+}
+/**
+ * The resulting output from running the git child process
+ */
+interface GitExecutorResult {
+    stdOut: Buffer[];
+    stdErr: Buffer[];
+    exitCode: number;
+    rejection: Maybe<Error>;
+}
+interface SimpleGitPluginConfig {
+    /**
+     * Configures the events that should be used to determine when the unederlying child process has
+     * been terminated.
+     *
+     * Version 2 will default to use `onClose=true, onExit=50` to mean the `close` event will be
+     * used to immediately treat the child process as closed and start using the data from `stdOut`
+     * / `stdErr`, whereas the `exit` event will wait `50ms` before treating the child process
+     * as closed.
+     *
+     * This will be changed in version 3 to use `onClose=true, onExit=false` so that only the
+     * close event is used to determine the termination of the process.
+     */
+    completion: {
+        onClose?: boolean | number;
+        onExit?: boolean | number;
+    };
+    /**
+     * Configures the content of errors thrown by the `simple-git` instance for each task
+     */
+    errors(error: Buffer | Error | undefined, result: Omit<GitExecutorResult, 'rejection'>): Buffer | Error | undefined;
+    /**
+     * Handler to be called with progress events emitted through the progress plugin
+     */
+    progress(data: SimpleGitProgressEvent): void;
+    /**
+     * Configuration for the `timeoutPlugin`
+     */
+    timeout: {
+        /**
+         * The number of milliseconds to wait after spawning the process / receiving
+         * content on the stdOut/stdErr streams before forcibly closing the git process.
+         */
+        block: number;
+    };
+    spawnOptions: Pick<SpawnOptions, 'uid' | 'gid'>;
+}
+/**
+ * Optional configuration settings to be passed to the `simpleGit`
+ * builder.
+ */
+interface SimpleGitOptions extends Partial<SimpleGitPluginConfig> {
+    baseDir: string;
+    binary: string;
+    maxConcurrentProcesses: number;
+    config: string[];
+}
+declare type Maybe<T> = T | undefined;
+
+interface DefaultLogFields {
+    hash: string;
+    date: string;
+    message: string;
+    refs: string;
+    body: string;
+    author_name: string;
+    author_email: string;
+}
+declare type LogOptions<T = DefaultLogFields> = {
+    file?: string;
+    format?: T;
+    from?: string;
+    mailMap?: boolean;
+    maxCount?: number;
+    multiLine?: boolean;
+    splitter?: string;
+    strictDate?: boolean;
+    symmetric?: boolean;
+    to?: string;
+};
+
+interface BranchSummaryBranch {
+   current: boolean;
+   name: string;
+   commit: string;
+   label: string;
+}
+
+interface BranchSummary {
+   detached: boolean;
+   current: string;
+   all: string[];
+   branches: {
+      [key: string]: BranchSummaryBranch;
+   };
+}
+
+/**
+ * Represents the successful deletion of a single branch
+ */
+interface BranchSingleDeleteSuccess {
+   branch: string;
+   hash: string;
+   success: true;
+}
+
+/**
+ * Represents the failure to delete a single branch
+ */
+interface BranchSingleDeleteFailure {
+   branch: string;
+   hash: null;
+   success: false;
+}
+
+type BranchSingleDeleteResult = BranchSingleDeleteFailure | BranchSingleDeleteSuccess;
+
+/**
+ * Represents the status of having deleted a batch of branches
+ */
+interface BranchMultiDeleteResult {
+   /**
+    * All branches included in the response
+    */
+   all: BranchSingleDeleteResult[];
+
+   /**
+    * Branches mapped by their branch name
+    */
+   branches: { [branchName: string]: BranchSingleDeleteResult };
+
+   /**
+    * Array of responses that are in error
+    */
+   errors: BranchSingleDeleteResult[];
+
+   /**
+    * Flag showing whether all branches were deleted successfully
+    */
+   readonly success: boolean;
+}
+
+interface CleanSummary {
+   readonly dryRun: boolean;
+   paths: string[];
+   files: string[];
+   folders: string[];
+}
+
+interface CommitResult {
+   author: null | {
+      email: string;
+      name: string;
+   };
+   branch: string;
+   commit: string;
+   root: boolean;
+   summary: {
+      changes: number;
+      insertions: number;
+      deletions: number;
+   };
+}
+
+/** Represents the response to using `git.getConfig` */
+interface ConfigGetResult {
+   /** The key that was searched for */
+   key: string;
+
+   /** The single value seen by `git` for this key (equivalent to `git config --get key`) */
+   value: string | null;
+
+   /** All possible values for this key no matter the scope (equivalent to `git config --get-all key`) */
+   values: string[];
+
+   /** The file paths from which configuration was read */
+   paths: string[];
+
+   /**
+    * The full hierarchy of values the property can have had across the
+    * various scopes that were searched (keys in this Map are the strings
+    * also found in the `paths` array).
+    */
+   scopes: Map<string, string[]>;
+}
+
+/**
+ * Represents the current git configuration, as defined by the output from `git log`
+ */
+interface ConfigListSummary {
+
+   /**
+    * All configuration settings, where local/user settings override user/global settings
+    * the overridden value will appear in this object.
+    */
+   readonly all: ConfigValues;
+
+   /**
+    * The file paths configuration was read from
+    */
+   files: string[];
+
+   /**
+    * The `ConfigValues` for each of the `files`, use this object to determine
+    * local repo, user and global settings.
+    */
+   values: { [fileName: string]: ConfigValues };
+}
+
+/**
+ * Represents the map of configuration settings
+ */
+interface ConfigValues {
+   [key: string]: string | string[];
+}
+
+interface DiffResultTextFile {
+   file: string;
+   changes: number;
+   insertions: number;
+   deletions: number;
+   binary: false;
+}
+
+interface DiffResultBinaryFile {
+   file: string;
+   before: number;
+   after: number;
+   binary: true;
+}
+
+interface DiffResult {
+   /** The total number of files changed as reported in the summary line */
+   changed: number;
+
+   /** When present in the diff, lists the details of each file changed */
+   files: Array<DiffResultTextFile | DiffResultBinaryFile>;
+
+   /** The number of files changed with insertions */
+   insertions: number;
+
+   /** The number of files changed with deletions */
+   deletions: number;
+}
+
+interface FetchResult {
+   raw: string;
+   remote: string | null;
+   branches: {
+      name: string;
+      tracking: string;
+   }[];
+   tags: {
+      name: string;
+      tracking: string;
+   }[];
+}
+
+/** Represents the response to git.grep */
+interface GrepResult {
+   paths: Set<string>;
+   results: Record<string, Array<{
+      line: number;
+      path: string;
+      preview: string;
+   }>>;
+}
+
+/**
+ * The `InitResult` is returned when (re)initialising a git repo.
+ */
+interface InitResult {
+   /**
+    * Boolean representing whether the `--bare` option was used
+    */
+   readonly bare: boolean;
+
+   /**
+    * Boolean representing whether the repo already existed (re-initialised rather than initialised)
+    */
+   readonly existing: boolean;
+
+   /**
+    * The path used when initialising
+    */
+   readonly path: string;
+
+   /**
+    * The git configuration directory - for a bare repo this is the same as `path`, in non-bare repos
+    * this will usually be a sub-directory with the name `.git` (or value of the `$GIT_DIR` environment
+    * variable).
+    */
+   readonly gitDir: string;
+}
+
+/**
+ * A parsed response summary for calls to `git mv`
+ */
+interface MoveResult {
+   /**
+    * Array of files moved
+    */
+   moves: Array<{ from: string, to: string }>;
+}
+
+interface PullDetailFileChanges {
+   [fileName: string]: number;
+}
+
+interface PullDetailSummary {
+   changes: number;
+   insertions: number;
+   deletions: number;
+}
+
+interface PullDetail {
+   /** Array of all files that are referenced in the pull */
+   files: string[];
+
+   /** Map of file names to the number of insertions in that file */
+   insertions: PullDetailFileChanges;
+
+   /** Map of file names to the number of deletions in that file */
+   deletions: PullDetailFileChanges;
+
+   summary: PullDetailSummary;
+
+   /** Array of file names that have been created */
+   created: string[];
+
+   /** Array of file names that have been deleted */
+   deleted: string[];
+}
+
+interface PullResult extends PullDetail, RemoteMessageResult {
+}
+
+/**
+ * Represents file name changes in a StatusResult
+ */
+interface StatusResultRenamed {
+   from: string;
+   to: string;
+}
+
+interface FileStatusResult {
+
+   /** Original location of the file, when the file has been moved */
+   from?: string
+
+   /** Path of the file */
+   path: string;
+
+   /** First digit of the status code of the file, e.g. 'M' = modified.
+    Represents the status of the index if no merge conflicts, otherwise represents
+    status of one side of the merge. */
+   index: string;
+
+   /** Second digit of the status code of the file. Represents status of the working directory
+    if no merge conflicts, otherwise represents status of other side of a merge. */
+   working_dir: string;
+}
+
+/**
+ * The StatusResult is returned for calls to `git.status()`, represents the state of the
+ * working directory.
+ */
+interface StatusResult {
+   not_added: string[];
+   conflicted: string[];
+   created: string[];
+   deleted: string[];
+
+   /**
+    * Ignored files are not listed by default, add `--ignored` to the task options in order to see
+    * this array of ignored files/paths.
+    *
+    * Note: ignored files will not be added to the `files` array, and will not be included in the
+    * `isClean()` calculation.
+    */
+   ignored?: string[];
+   modified: string[];
+   renamed: StatusResultRenamed[];
+   staged: string[];
+
+   /**
+    * All files represented as an array of objects containing the `path` and status in `index` and
+    * in the `working_dir`.
+    */
+   files: FileStatusResult[];
+
+   /**
+    * Number of commits ahead of the tracked branch
+    */
+   ahead: number;
+
+   /**
+    *Number of commits behind the tracked branch
+    */
+   behind: number;
+
+   /**
+    * Name of the current branch
+    */
+   current: string | null;
+
+   /**
+    * Name of the branch being tracked
+    */
+   tracking: string | null;
+
+   /**
+    * Detached status of the working copy, for more detail of what the working branch
+    * is detached from use `git.branch()`
+    */
+   detached: boolean;
+
+   /**
+    * Gets whether this represents a clean working branch.
+    */
+   isClean(): boolean;
+}
+
+/**
+ * Response retrieved when using the `git.tags` method
+ */
+interface TagResult {
+   /**
+    * All tag names
+    */
+   all: string[];
+
+   /**
+    * The semver latest tag name or `undefined` when no tags are named in the response
+    */
+   latest: string | undefined;
+}
+
+/**
+ * The ListLogLine represents a single entry in the `git.log`, the properties on the object
+ * are mixed in depending on the names used in the format (see `DefaultLogFields`), but some
+ * properties are dependent on the command used.
+ */
+interface ListLogLine {
+   /**
+    * When using a `--stat=4096` or `--shortstat` options in the `git.log` or `git.stashList`,
+    * each entry in the `ListLogSummary` will also have a `diff` property representing as much
+    * detail as was given in the response.
+    */
+   diff?: DiffResult;
+}
+
+interface LogResult<T = DefaultLogFields> {
+   all: ReadonlyArray<T & ListLogLine>;
+   total: number;
+   latest: (T & ListLogLine) | null;
+}
+
+/**
+ * Where the file was deleted, if there is a modify/delete conflict
+ */
+interface MergeConflictDeletion {
+   deleteRef: string;
+}
+
+/**
+ * Represents a single file with conflicts in the MergeSummary
+ */
+interface MergeConflict {
+
+   /**
+    * Type of conflict
+    */
+   reason: string;
+
+   /**
+    * Path to file
+    */
+   file: string | null;
+
+   /**
+    * Additional detail for the specific type of conflict
+    */
+   meta?: MergeConflictDeletion;
+}
+
+type MergeResultStatus = 'success' | string;
+
+interface MergeDetail {
+   conflicts: MergeConflict[];
+   merges: string[];
+   result: MergeResultStatus;
+   readonly failed: boolean;
+}
+
+type MergeResult = PullResult & MergeDetail;
+
+/**
+ *
+ */
+interface PushResultPushedItem {
+   local: string;
+   remote: string;
+
+   readonly deleted: boolean;
+   readonly tag: boolean;
+   readonly branch: boolean;
+   readonly new: boolean;
+   readonly alreadyUpdated: boolean;
+}
+
+interface RemoteMessagesObjectEnumeration {
+   enumerating: number,
+   counting: number,
+   compressing: number,
+   total: {
+      count: number,
+      delta: number,
+   },
+   reused: {
+      count: number,
+      delta: number,
+   },
+   packReused: number,
+}
+
+interface RemoteMessages {
+   all: string[];
+   objects?: RemoteMessagesObjectEnumeration;
+}
+
+interface PushResultRemoteMessages extends RemoteMessages {
+   pullRequestUrl?: string;
+   vulnerabilities?: {
+      count: number;
+      summary: string;
+      url: string;
+   };
+}
+
+interface RemoteMessageResult<T extends RemoteMessages = RemoteMessages> {
+   remoteMessages: T;
+}
+
+interface PushResultBranchUpdate {
+   head: {
+      local: string;
+      remote: string;
+   };
+   hash: {
+      from: string;
+      to: string;
+   };
+}
+
+interface PushDetail {
+   repo?: string;
+   ref?: {
+      local: string;
+   };
+   pushed: PushResultPushedItem[];
+   branch?: {
+      local: string;
+      remote: string;
+      remoteName: string;
+   };
+   update?: PushResultBranchUpdate;
+}
+
+interface PushResult extends PushDetail, RemoteMessageResult<PushResultRemoteMessages> {
+}
+
+type MoveSummary = MoveResult;
+
+interface RemoteWithoutRefs {
+    name: string;
+}
+interface RemoteWithRefs extends RemoteWithoutRefs {
+    refs: {
+        fetch: string;
+        push: string;
+    };
+}
+
+declare type ApplyOptions = Options$1 & OptionFlags<'--stat' | '--numstat' | '--summary' | '--check' | '--index' | '--intent-to-add' | '--3way' | '--apply' | '--no-add' | '-R' | '--reverse' | '--allow-binary-replacement' | '--binary' | '--reject' | '-z' | '--inaccurate-eof' | '--recount' | '--cached' | '--ignore-space-change' | '--ignore-whitespace' | '--verbose' | '--unsafe-paths'> & OptionFlags<'--whitespace', 'nowarn' | 'warn' | 'fix' | 'error' | 'error-all'> & OptionFlags<'--build-fake-ancestor' | '--exclude' | '--include' | '--directory', string> & OptionFlags<'-p' | '-C', number>;
+
+declare enum CheckRepoActions {
+    BARE = "bare",
+    IN_TREE = "tree",
+    IS_REPO_ROOT = "root"
+}
+
+/**
+ * All supported option switches available for use in a `git.clean` operation
+ */
+declare enum CleanOptions {
+    DRY_RUN = "n",
+    FORCE = "f",
+    IGNORED_INCLUDED = "x",
+    IGNORED_ONLY = "X",
+    EXCLUDING = "e",
+    QUIET = "q",
+    RECURSIVE = "d"
+}
+/**
+ * The two modes `git.clean` can run in - one of these must be supplied in order
+ * for the command to not throw a `TaskConfigurationError`
+ */
+declare type CleanMode = CleanOptions.FORCE | CleanOptions.DRY_RUN;
+
+declare enum GitConfigScope {
+    system = "system",
+    global = "global",
+    local = "local",
+    worktree = "worktree"
+}
+
+interface GitGrepQuery extends Iterable<string> {
+    /** Adds one or more terms to be grouped as an "and" to any other terms */
+    and(...and: string[]): this;
+    /** Adds one or more search terms - git.grep will "or" this to other terms */
+    param(...param: string[]): this;
+}
+
+declare enum ResetMode {
+    MIXED = "mixed",
+    SOFT = "soft",
+    HARD = "hard",
+    MERGE = "merge",
+    KEEP = "keep"
+}
+declare type ResetOptions = Options$1 & OptionFlags<'-q' | '--quiet' | '--no-quiet' | '--pathspec-from-nul'> & OptionFlags<'--pathspec-from-file', string>;
+
+interface SimpleGitFactory {
+   (baseDir?: string, options?: Partial<SimpleGitOptions>): SimpleGit;
+
+   (baseDir: string): SimpleGit;
+
+   (options: Partial<SimpleGitOptions>): SimpleGit;
+}
+
+type Response$2<T> = SimpleGit & Promise<T>;
+
+interface SimpleGitBase {
+   /**
+    * Adds one or more files to source control
+    */
+   add(files: string | string[], callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Sets the working directory of the subsequent commands.
+    */
+   cwd(directory: { path: string, root?: boolean }, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   cwd<path extends string>(directory: path, callback?: SimpleGitTaskCallback<path>): Response$2<path>;
+
+   /**
+    * Compute object ID from a file
+    */
+   hashObject(path: string, callback?: SimpleGitTaskCallback): Response$2<string>;
+
+   hashObject(path: string, write ?: boolean, callback?: SimpleGitTaskCallback): Response$2<string>;
+
+   /**
+    * Initialize a git repo
+    */
+   init(bare: boolean, options?: TaskOptions, callback?: SimpleGitTaskCallback<InitResult>): Response$2<InitResult>;
+
+   init(bare: boolean, callback?: SimpleGitTaskCallback<InitResult>): Response$2<InitResult>;
+
+   init(options?: TaskOptions, callback?: SimpleGitTaskCallback<InitResult>): Response$2<InitResult>;
+
+   init(callback?: SimpleGitTaskCallback<InitResult>): Response$2<InitResult>;
+
+   /**
+    * Runs a merge, `options` can be either an array of arguments
+    * supported by the [`git merge`](https://git-scm.com/docs/git-merge)
+    * or an options object.
+    *
+    * Conflicts during the merge result in an error response,
+    * the response type whether it was an error or success will be a MergeSummary instance.
+    * When successful, the MergeSummary has all detail from a the PullSummary
+    *
+    * @see https://github.com/steveukx/git-js/blob/master/src/responses/MergeSummary.js
+    * @see https://github.com/steveukx/git-js/blob/master/src/responses/PullSummary.js
+    */
+   merge(options: TaskOptions, callback?: SimpleGitTaskCallback<MergeResult>): Response$2<MergeResult>;
+
+   /**
+    * Merges from one branch to another, equivalent to running `git merge ${remote} ${branch}`, the `options` argument can
+    * either be an array of additional parameters to pass to the command or null / omitted to be ignored.
+    */
+   mergeFromTo<E extends GitError>(remote: string, branch: string, options?: TaskOptions, callback?: SimpleGitTaskCallback<MergeResult, E>): Response$2<MergeResult>;
+
+   mergeFromTo<E extends GitError>(remote: string, branch: string, callback?: SimpleGitTaskCallback<MergeResult, E>): Response$2<MergeResult>;
+
+   /**
+    * Sets a handler function to be called whenever a new child process is created, the handler function will be called
+    * with the name of the command being run and the stdout & stderr streams used by the ChildProcess.
+    *
+    * @example
+    * require('simple-git')
+    *    .outputHandler(function (command, stdout, stderr) {
+    *       stdout.pipe(process.stdout);
+    *    })
+    *    .checkout('https://github.com/user/repo.git');
+    *
+    * @see https://nodejs.org/api/child_process.html#child_process_class_childprocess
+    * @see https://nodejs.org/api/stream.html#stream_class_stream_readable
+    */
+   outputHandler(handler: outputHandler | void): this;
+
+   /**
+    * Pushes the current committed changes to a remote, optionally specify the names of the remote and branch to use
+    * when pushing. Supply multiple options as an array of strings in the first argument - see examples below.
+    */
+   push(remote?: string, branch?: string, options?: TaskOptions, callback?: SimpleGitTaskCallback<PushResult>): Response$2<PushResult>;
+
+   push(options?: TaskOptions, callback?: SimpleGitTaskCallback<PushResult>): Response$2<PushResult>;
+
+   push(callback?: SimpleGitTaskCallback<PushResult>): Response$2<PushResult>;
+
+   /**
+    * Stash the local repo
+    */
+   stash(options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   stash(callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Show the working tree status.
+    */
+   status(options?: TaskOptions, callback?: SimpleGitTaskCallback<StatusResult>): Response$2<StatusResult>;
+
+   status(callback?: SimpleGitTaskCallback<StatusResult>): Response$2<StatusResult>;
+
+}
+
+interface SimpleGit extends SimpleGitBase {
+
+   /**
+    * Add an annotated tag to the head of the current branch
+    */
+   addAnnotatedTag(tagName: string, tagMessage: string, callback?: SimpleGitTaskCallback<{ name: string }>): Response$2<{ name: string }>;
+
+   /**
+    * Add config to local git instance for the specified `key` (eg: user.name) and value (eg: 'your name').
+    * Set `append` to true to append to rather than overwrite the key
+    */
+   addConfig(key: string, value: string, append?: boolean, scope?: keyof typeof GitConfigScope, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   addConfig(key: string, value: string, append?: boolean, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   addConfig(key: string, value: string, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Applies a patch to the repo
+    */
+   applyPatch(patches: string | string[], options: TaskOptions<ApplyOptions>, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   applyPatch(patches: string | string[], callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Configuration values visible to git in the current working directory
+    */
+   listConfig(scope: keyof typeof GitConfigScope, callback?: SimpleGitTaskCallback<ConfigListSummary>): Response$2<ConfigListSummary>;
+
+   listConfig(callback?: SimpleGitTaskCallback<ConfigListSummary>): Response$2<ConfigListSummary>;
+
+   /**
+    * Adds a remote to the list of remotes.
+    *
+    * - `remoteName` Name of the repository - eg "upstream"
+    * - `remoteRepo` Fully qualified SSH or HTTP(S) path to the remote repo
+    * - `options` Optional additional settings permitted by the `git remote add` command, merged into the command prior to the repo name and remote url
+    */
+   addRemote(remoteName: string, remoteRepo: string, options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   addRemote(remoteName: string, remoteRepo: string, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Add a lightweight tag to the head of the current branch
+    */
+   addTag(name: string, callback?: SimpleGitTaskCallback<{ name: string }>): Response$2<{ name: string }>;
+
+   /**
+    * Equivalent to `catFile` but will return the native `Buffer` of content from the git command's stdout.
+    */
+   binaryCatFile(options: string[], callback?: SimpleGitTaskCallback<any>): Response$2<any>;
+
+   /**
+    * List all branches
+    */
+   branch(options?: TaskOptions, callback?: SimpleGitTaskCallback<BranchSummary>): Response$2<BranchSummary>;
+
+   /**
+    * List of local branches
+    */
+   branchLocal(callback?: SimpleGitTaskCallback<BranchSummary>): Response$2<BranchSummary>;
+
+   /**
+    * Returns a list of objects in a tree based on commit hash.
+    * Passing in an object hash returns the object's content, size, and type.
+    *
+    * Passing "-p" will instruct cat-file to determine the object type, and display its formatted contents.
+    *
+    * @see https://git-scm.com/docs/git-cat-file
+    */
+   catFile(options: string[], callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   catFile(callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Check if a pathname or pathnames are excluded by .gitignore
+    *
+    */
+   checkIgnore(pathNames: string[], callback?: SimpleGitTaskCallback<string[]>): Response$2<string[]>;
+
+   checkIgnore(path: string, callback?: SimpleGitTaskCallback<string[]>): Response$2<string[]>;
+
+   /**
+    * Validates that the current working directory is a valid git repo file path.
+    *
+    * To make a more specific assertion of the repo, add the `action` argument:
+    *
+    * - `bare` to validate that the working directory is inside a bare repo.
+    * - `root` to validate that the working directory is the root of a repo.
+    * - `tree` (default value when omitted) to simply validate that the working
+    *    directory is the descendent of a repo
+    */
+   checkIsRepo(action?: CheckRepoActions, callback?: SimpleGitTaskCallback<boolean>): Response$2<boolean>;
+
+   checkIsRepo(callback?: SimpleGitTaskCallback<boolean>): Response$2<boolean>;
+
+   /**
+    * Checkout a tag or revision, any number of additional arguments can be passed to the `git checkout` command
+    * by supplying either a string or array of strings as the `what` parameter.
+    */
+   checkout(what: string, options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   checkout(what: string, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   checkout(options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Checkout a remote branch.
+    *
+    * - branchName name of branch.
+    * - startPoint (e.g origin/development).
+    */
+   checkoutBranch(branchName: string, startPoint: string, callback?: SimpleGitTaskCallback<void>): Response$2<void>;
+
+   /**
+    * Internally uses pull and tags to get the list of tags then checks out the latest tag.
+    */
+   checkoutLatestTag(branchName: string, startPoint: string, callback?: SimpleGitTaskCallback<void>): Response$2<void>;
+
+   /**
+    * Checkout a local branch
+    */
+   checkoutLocalBranch(branchName: string, callback?: SimpleGitTaskCallback<void>): Response$2<void>;
+
+   /**
+    * Deletes unwanted content from the local repo - when supplying the first argument as
+    * an array of `CleanOptions`, the array must include one of `CleanOptions.FORCE` or
+    * `CleanOptions.DRY_RUN`.
+    *
+    * eg:
+    *
+    * ```typescript
+    await git.clean(CleanOptions.FORCE);
+    await git.clean(CleanOptions.DRY_RUN + CleanOptions.RECURSIVE);
+    await git.clean(CleanOptions.FORCE, ['./path']);
+    await git.clean(CleanOptions.IGNORED + CleanOptions.FORCE, {'./path': null});
+    * ```
+    */
+   clean(args: CleanOptions[], options?: TaskOptions, callback?: SimpleGitTaskCallback<CleanSummary>): Response$2<CleanSummary>;
+
+   clean(mode: CleanMode | string, options?: TaskOptions, callback?: SimpleGitTaskCallback<CleanSummary>): Response$2<CleanSummary>;
+
+   clean(mode: CleanMode | string, callback?: SimpleGitTaskCallback<CleanSummary>): Response$2<CleanSummary>;
+
+   clean(options?: TaskOptions): Response$2<CleanSummary>;
+
+   clean(callback?: SimpleGitTaskCallback<CleanSummary>): Response$2<CleanSummary>;
+
+   /**
+    * Clears the queue of pending commands and returns the wrapper instance for chaining.
+    */
+   clearQueue(): this;
+
+   /**
+    * Clone a repository into a new directory.
+    *
+    * - repoPath repository url to clone e.g. https://github.com/steveukx/git-js.git
+    * -  localPath local folder path to clone to.
+    * - options supported by [git](https://git-scm.com/docs/git-clone).
+    */
+   clone(repoPath: string, localPath: string, options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   clone(repoPath: string, options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Commits changes in the current working directory - when specific file paths are supplied, only changes on those
+    * files will be committed.
+    */
+   commit(
+      message: string | string[],
+      files?: string | string[],
+      options?: Options$1,
+      callback?: SimpleGitTaskCallback<CommitResult>): Response$2<CommitResult>;
+
+   commit(
+      message: string | string[],
+      options?: TaskOptions,
+      callback?: SimpleGitTaskCallback<CommitResult>): Response$2<CommitResult>;
+
+   commit(
+      message: string | string[],
+      files?: string | string[],
+      callback?: SimpleGitTaskCallback<CommitResult>): Response$2<CommitResult>;
+
+   commit(
+      message: string | string[],
+      callback?: SimpleGitTaskCallback<CommitResult>): Response$2<CommitResult>;
+
+   /**
+    * Sets the path to a custom git binary, should either be `git` when there is an installation of git available on
+    * the system path, or a fully qualified path to the executable.
+    */
+   customBinary(command: string): this;
+
+   /**
+    * Delete one local branch. Supply the branchName as a string to return a
+    * single `BranchDeletionSummary` instances.
+    *
+    * - branchName name of branch
+    * - forceDelete (optional, defaults to false) set to true to forcibly delete unmerged branches
+    */
+   deleteLocalBranch(branchName: string, forceDelete?: boolean, callback?: SimpleGitTaskCallback<BranchSingleDeleteResult>): Response$2<BranchSingleDeleteResult>;
+
+   deleteLocalBranch(branchName: string, callback?: SimpleGitTaskCallback<BranchSingleDeleteResult>): Response$2<BranchSingleDeleteResult>;
+
+   /**
+    * Delete one or more local branches. Supply the branchName as a string to return a
+    * single `BranchDeletionSummary` or as an array of branch names to return an array of
+    * `BranchDeletionSummary` instances.
+    *
+    * - branchNames name of branch or array of branch names
+    * - forceDelete (optional, defaults to false) set to true to forcibly delete unmerged branches
+    */
+   deleteLocalBranches(branchNames: string[], forceDelete?: boolean, callback?: SimpleGitTaskCallback<BranchMultiDeleteResult>): Response$2<BranchMultiDeleteResult>;
+
+   /**
+    * Get the diff of the current repo compared to the last commit with a set of options supplied as a string.
+    */
+   diff(options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Gets a summary of the diff for files in the repo, uses the `git diff --stat` format to calculate changes.
+    *
+    * in order to get staged (only): `--cached` or `--staged`.
+    */
+   diffSummary(command: string | number, options: TaskOptions, callback?: SimpleGitTaskCallback<DiffResult>): Response$2<DiffResult>;
+
+   diffSummary(command: string | number, callback?: SimpleGitTaskCallback<DiffResult>): Response$2<DiffResult>;
+
+   diffSummary(options: TaskOptions, callback?: SimpleGitTaskCallback<DiffResult>): Response$2<DiffResult>;
+
+   diffSummary(callback?: SimpleGitTaskCallback<DiffResult>): Response$2<DiffResult>;
+
+   /**
+    * Sets an environment variable for the spawned child process, either supply both a name and value as strings or
+    * a single object to entirely replace the current environment variables.
+    *
+    * @param {string|Object} name
+    * @param {string} [value]
+    */
+   env(name: string, value: string): this;
+
+   env(env: object): this;
+
+   /**
+    * Calls the supplied `handle` function at the next step in the chain, used to run arbitrary functions synchronously
+    * before the next task in the git api.
+    */
+   exec(handle: () => void): Response$2<void>;
+
+   /**
+    * Updates the local working copy database with changes from the default remote repo and branch.
+    */
+   fetch(remote: string, branch: string, options?: TaskOptions, callback?: SimpleGitTaskCallback<FetchResult>): Response$2<FetchResult>;
+
+   fetch(remote: string, branch: string, callback?: SimpleGitTaskCallback<FetchResult>): Response$2<FetchResult>;
+
+   fetch(remote: string, options?: TaskOptions, callback?: SimpleGitTaskCallback<FetchResult>): Response$2<FetchResult>;
+
+   fetch(options?: TaskOptions, callback?: SimpleGitTaskCallback<FetchResult>): Response$2<FetchResult>;
+
+   fetch(callback?: SimpleGitTaskCallback<FetchResult>): Response$2<FetchResult>;
+
+   /**
+    * Gets the current value of a configuration property by it key, optionally specify the scope in which
+    * to run the command (omit / set to `undefined` to check in the complete overlaid configuration visible
+    * to the `git` process).
+    */
+   getConfig(key: string, scope?: keyof typeof GitConfigScope, callback?: SimpleGitTaskCallback<string>): Response$2<ConfigGetResult>;
+
+   /**
+    * Gets the currently available remotes, setting the optional verbose argument to true includes additional
+    * detail on the remotes themselves.
+    */
+   getRemotes(callback?: SimpleGitTaskCallback<RemoteWithoutRefs[]>): Response$2<RemoteWithoutRefs[]>;
+
+   getRemotes(verbose?: false, callback?: SimpleGitTaskCallback<RemoteWithoutRefs[]>): Response$2<RemoteWithoutRefs[]>;
+
+   getRemotes(verbose: true, callback?: SimpleGitTaskCallback<RemoteWithRefs[]>): Response$2<RemoteWithRefs[]>;
+
+   /**
+    * Search for files matching the supplied search terms
+    */
+   grep(searchTerm: string | GitGrepQuery, callback?: SimpleGitTaskCallback<GrepResult>): Response$2<GrepResult>;
+
+   grep(searchTerm: string | GitGrepQuery, options?: TaskOptions, callback?: SimpleGitTaskCallback<GrepResult>): Response$2<GrepResult>;
+
+   /**
+    * List remotes by running the `ls-remote` command with any number of arbitrary options
+    * in either array of object form.
+    */
+   listRemote(args?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Show commit logs from `HEAD` to the first commit.
+    * If provided between `options.from` and `options.to` tags or branch.
+    *
+    * You can provide `options.file`, which is the path to a file in your repository. Then only this file will be considered.
+    *
+    * To use a custom splitter in the log format, set `options.splitter` to be the string the log should be split on.
+    *
+    * By default the following fields will be part of the result:
+    *   `hash`: full commit hash
+    *   `date`: author date, ISO 8601-like format
+    *   `message`: subject + ref names, like the --decorate option of git-log
+    *   `author_name`: author name
+    *   `author_email`: author mail
+    * You can specify `options.format` to be an mapping from key to a format option like `%H` (for commit hash).
+    * The fields specified in `options.format` will be the fields in the result.
+    *
+    * Options can also be supplied as a standard options object for adding custom properties supported by the git log command.
+    * For any other set of options, supply options as an array of strings to be appended to the git log command.
+    *
+    * @returns Response<ListLogSummary>
+    *
+    * @see https://git-scm.com/docs/git-log
+    */
+   log<T = DefaultLogFields>(options?: TaskOptions | LogOptions<T>, callback?: SimpleGitTaskCallback<LogResult<T>>): Response$2<LogResult<T>>;
+
+   /**
+    * Mirror a git repo
+    *
+    * Equivalent to `git.clone(repoPath, localPath, ['--mirror'])`, `clone` allows
+    * for additional task options.
+    */
+   mirror(repoPath: string, localPath: string, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Moves one or more files to a new destination.
+    *
+    * @see https://git-scm.com/docs/git-mv
+    */
+   mv(from: string | string[], to: string, callback?: SimpleGitTaskCallback<MoveSummary>): Response$2<MoveSummary>;
+
+   /**
+    * Fetch from and integrate with another repository or a local branch. In the case that the `git pull` fails with a
+    * recognised fatal error, the exception thrown by this function will be a `GitResponseError<PullFailedResult>`.
+    */
+   pull(remote?: string, branch?: string, options?: TaskOptions, callback?: SimpleGitTaskCallback<PullResult>): Response$2<PullResult>;
+
+   pull(options?: TaskOptions, callback?: SimpleGitTaskCallback<PullResult>): Response$2<PullResult>;
+
+   pull(callback?: SimpleGitTaskCallback<PullResult>): Response$2<PullResult>;
+
+   /**
+    * Pushes the current tag changes to a remote which can be either a URL or named remote. When not specified uses the
+    * default configured remote spec.
+    */
+   pushTags(remote: string, options?: TaskOptions, callback?: SimpleGitTaskCallback<PushResult>): Response$2<PushResult>;
+
+   pushTags(options?: TaskOptions, callback?: SimpleGitTaskCallback<PushResult>): Response$2<PushResult>;
+
+   pushTags(callback?: SimpleGitTaskCallback<PushResult>): Response$2<PushResult>;
+
+   /**
+    * Executes any command against the git binary.
+    */
+   raw(commands: string | string[] | TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   raw(options: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   raw(...commands: string[]): Response$2<string>;
+
+   // leading varargs with trailing options/callback
+   raw(a: string, options: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   raw(a: string, b: string, options: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   raw(a: string, b: string, c: string, options: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   raw(a: string, b: string, c: string, d: string, options: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   raw(a: string, b: string, c: string, d: string, e: string, options: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   // leading varargs with trailing callback
+   raw(a: string, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   raw(a: string, b: string, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   raw(a: string, b: string, c: string, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   raw(a: string, b: string, c: string, d: string, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   raw(a: string, b: string, c: string, d: string, e: string, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Rebases the current working copy. Options can be supplied either as an array of string parameters
+    * to be sent to the `git rebase` command, or a standard options object.
+    */
+   rebase(options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   rebase(callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Call any `git remote` function with arguments passed as an array of strings.
+    */
+   remote(options: string[], callback?: SimpleGitTaskCallback<void | string>): Response$2<void | string>;
+
+   /**
+    * Removes an entry from the list of remotes.
+    *
+    * - remoteName Name of the repository - eg "upstream"
+    */
+   removeRemote(remoteName: string, callback?: SimpleGitTaskCallback<void>): Response$2<void>;
+
+   /**
+    * Reset a repo. Called without arguments this is a soft reset for the whole repo,
+    * for explicitly setting the reset mode, supply the first argument as one of the
+    * supported reset modes.
+    *
+    * Trailing options argument can be either a string array, or an extension of the
+    * ResetOptions, use this argument for supplying arbitrary additional arguments,
+    * such as restricting the pathspec.
+    *
+    * ```typescript
+    // equivalent to each other
+    simpleGit().reset(ResetMode.HARD, ['--', 'my-file.txt']);
+    simpleGit().reset(['--hard', '--', 'my-file.txt']);
+    simpleGit().reset(ResetMode.HARD, {'--': null, 'my-file.txt': null});
+    simpleGit().reset({'--hard': null, '--': null, 'my-file.txt': null});
+    ```
+    */
+   reset(mode: ResetMode, options?: TaskOptions<ResetOptions>, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   reset(mode: ResetMode, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   reset(options?: TaskOptions<ResetOptions>, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Revert one or more commits in the local working copy
+    *
+    * - commit The commit to revert. Can be any hash, offset (eg: `HEAD~2`) or range (eg: `master~5..master~2`)
+    */
+   revert(commit: String, options?: TaskOptions, callback?: SimpleGitTaskCallback<void>): Response$2<void>;
+
+   revert(commit: String, callback?: SimpleGitTaskCallback<void>): Response$2<void>;
+
+   /**
+    * Passes the supplied options to `git rev-parse` and returns the string response. Options can be either a
+    * string array or `Options` object of options compatible with the [rev-parse](https://git-scm.com/docs/git-rev-parse)
+    *
+    * Example uses of `rev-parse` include converting friendly commit references (ie: branch names) to SHA1 hashes
+    * and retrieving meta details about the current repo (eg: the root directory, and whether it was created as
+    * a bare repo).
+    */
+   revparse(option: string, options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   revparse(options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Removes the named files from source control.
+    */
+   rm(paths: string | string[], callback?: SimpleGitTaskCallback<void>): Response$2<void>;
+
+   /**
+    * Removes the named files from source control but keeps them on disk rather than deleting them entirely. To
+    * completely remove the files, use `rm`.
+    */
+   rmKeepLocal(paths: string | string[], callback?: SimpleGitTaskCallback<void>): Response$2<void>;
+
+   /**
+    * Show various types of objects, for example the file at a certain commit
+    */
+   show(option: string | TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   show(callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * @deprecated
+    *
+    * From version 2.7.0, use of `silent` is deprecated in favour of using the `debug` library, this method will
+    * be removed in version 3.x.
+    *
+    * Please see the [readme](https://github.com/steveukx/git-js/blob/master/readme.md#enable-logging) for more details.
+    *
+    * Disables/enables the use of the console for printing warnings and errors, by default messages are not shown in
+    * a production environment.
+    *
+    * @param {boolean} silence
+    */
+   silent(silence?: boolean): this;
+
+   /**
+    * List the stash(s) of the local repo
+    */
+   stashList(options?: TaskOptions, callback?: SimpleGitTaskCallback<LogResult>): Response$2<LogResult>;
+
+   stashList(callback?: SimpleGitTaskCallback<LogResult>): Response$2<LogResult>;
+
+   /**
+    * Call any `git submodule` function with arguments passed as an array of strings.
+    */
+   subModule(options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Add a submodule
+    */
+   submoduleAdd(repo: string, path: string, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Initialise submodules
+    */
+   submoduleInit(moduleName: string, options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   submoduleInit(moduleName: string, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   submoduleInit(options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   submoduleInit(callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Update submodules
+    */
+   submoduleUpdate(moduleName: string, options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   submoduleUpdate(moduleName: string, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   submoduleUpdate(options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   submoduleUpdate(callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * List all tags. When using git 2.7.0 or above, include an options object with `"--sort": "property-name"` to
+    * sort the tags by that property instead of using the default semantic versioning sort.
+    *
+    * Note, supplying this option when it is not supported by your Git version will cause the operation to fail.
+    */
+   tag(options?: TaskOptions, callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+
+   /**
+    * Gets a list of tagged versions.
+    */
+   tags(options?: TaskOptions, callback?: SimpleGitTaskCallback<TagResult>): Response$2<TagResult>;
+
+   tags(callback?: SimpleGitTaskCallback<TagResult>): Response$2<TagResult>;
+
+   /**
+    * Updates repository server info
+    */
+   updateServerInfo(callback?: SimpleGitTaskCallback<string>): Response$2<string>;
+}
+
+declare const factory: SimpleGitFactory;
+
+declare const git_factory: typeof factory;
+declare namespace git {
+  export {
+    git_factory as factory,
+  };
+}
+
 declare enum ContentTokenType {
     Command = 0,
     Path = 1,
-    Link = 2
+    Link = 2,
+    Yellow = 3,
+    Cyan = 4,
+    Magenta = 5,
+    Green = 6
 }
 interface ContentMetadata {
     link?: string;
@@ -2004,6 +3588,10 @@ declare const token: {
     command: (value: string) => ContentToken;
     path: (value: string) => ContentToken;
     link: (value: string, link: string) => ContentToken;
+    cyan: (value: string) => ContentToken;
+    yellow: (value: string) => ContentToken;
+    magenta: (value: string) => ContentToken;
+    green: (value: string) => ContentToken;
 };
 declare class TokenizedString {
     value: string;
@@ -2062,6 +3650,7 @@ declare const error: (content: Fatal) => void;
 declare function stringifyMessage(message: Message): string;
 
 declare const output$1_token: typeof token;
+type output$1_Message = Message;
 declare const output$1_content: typeof content;
 type output$1_LogLevel = LogLevel;
 declare const output$1_currentLogLevel: typeof currentLogLevel;
@@ -2076,6 +3665,7 @@ declare const output$1_stringifyMessage: typeof stringifyMessage;
 declare namespace output$1 {
   export {
     output$1_token as token,
+    output$1_Message as Message,
     output$1_content as content,
     output$1_LogLevel as LogLevel,
     output$1_currentLogLevel as currentLogLevel,
@@ -5307,5 +6897,5 @@ declare const constants: {
     };
 };
 
-export { api, checksum, constants, dependency, environment, error$1 as error, file, http, os, output$1 as output, path, schema, session, store, string, system, template, toml, ui, version };
+export { api, checksum, constants, dependency, environment, error$1 as error, file, git, http, os, output$1 as output, path, schema, session, store, string, system, template, toml, ui, version };
 //# sourceMappingURL=index.d.ts.map