plugin-agent-orchestrator 1.0.6 → 1.0.14

package/dist/node_modules/simple-git/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/node_modules/simple-git/dist/src/lib/api.d.ts

@@ -0,0 +1,13 @@
+import { pathspec } from '@simple-git/args-pathspec';
+import { GitConstructError } from './errors/git-construct-error';
+import { GitError } from './errors/git-error';
+import { GitPluginError } from './errors/git-plugin-error';
+import { GitResponseError } from './errors/git-response-error';
+import { TaskConfigurationError } from './errors/task-configuration-error';
+import { CheckRepoActions } from './tasks/check-is-repo';
+import { CleanOptions } from './tasks/clean';
+import { GitConfigScope } from './tasks/config';
+import { DiffNameStatus } from './tasks/diff-name-status';
+import { grepQueryBuilder } from './tasks/grep';
+import { ResetMode } from './tasks/reset';
+export { CheckRepoActions, CleanOptions, DiffNameStatus, GitConfigScope, GitConstructError, GitError, GitPluginError, GitResponseError, ResetMode, TaskConfigurationError, grepQueryBuilder, pathspec, };

package/dist/node_modules/simple-git/dist/src/lib/args/log-format.d.ts

@@ -0,0 +1,9 @@
+export declare enum LogFormat {
+    NONE = "",
+    STAT = "--stat",
+    NUM_STAT = "--numstat",
+    NAME_ONLY = "--name-only",
+    NAME_STATUS = "--name-status"
+}
+export declare function logFormatFromCommand(customArgs: string[]): LogFormat;
+export declare function isLogFormat(customArg: string | unknown): boolean;

package/dist/node_modules/simple-git/dist/src/lib/errors/git-construct-error.d.ts

@@ -0,0 +1,15 @@
+import { GitError } from './git-error';
+import { SimpleGitOptions } from '../types';
+/**
+ * The `GitConstructError` is thrown when an error occurs in the constructor
+ * of the `simple-git` instance itself. Most commonly as a result of using
+ * a `baseDir` option that points to a folder that either does not exist,
+ * or cannot be read by the user the node script is running as.
+ *
+ * Check the `.message` property for more detail including the properties
+ * passed to the constructor.
+ */
+export declare class GitConstructError extends GitError {
+    readonly config: SimpleGitOptions;
+    constructor(config: SimpleGitOptions, message: string);
+}

package/dist/node_modules/simple-git/dist/src/lib/errors/git-error.d.ts

@@ -0,0 +1,30 @@
+import type { SimpleGitTask } from '../types';
+/**
+ * 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);
+ ```
+ */
+export declare class GitError extends Error {
+    task?: SimpleGitTask<any> | undefined;
+    constructor(task?: SimpleGitTask<any> | undefined, message?: string);
+}

package/dist/node_modules/simple-git/dist/src/lib/errors/git-plugin-error.d.ts

@@ -0,0 +1,7 @@
+import { SimpleGitOptions, SimpleGitTask } from '../types';
+import { GitError } from './git-error';
+export declare class GitPluginError extends GitError {
+    task?: SimpleGitTask<any> | undefined;
+    readonly plugin?: keyof SimpleGitOptions | undefined;
+    constructor(task?: SimpleGitTask<any> | undefined, plugin?: keyof SimpleGitOptions | undefined, message?: string);
+}

package/dist/node_modules/simple-git/dist/src/lib/errors/git-response-error.d.ts

@@ -0,0 +1,32 @@
+import { GitError } from './git-error';
+/**
+ * The `GitResponseError` is the wrapper for a parsed response that is treated as
+ * a fatal error, for example attempting a `merge` can leave the repo in a corrupted
+ * state when there are conflicts so the task will reject rather than resolve.
+ *
+ * For example, catching the merge conflict exception:
+ *
+ * ```typescript
+ import { gitP, SimpleGit, GitResponseError, MergeSummary } from 'simple-git';
+
+ const git = gitP(repoRoot);
+ const mergeOptions: string[] = ['--no-ff', 'other-branch'];
+ const mergeSummary: MergeSummary = await git.merge(mergeOptions)
+      .catch((e: GitResponseError<MergeSummary>) => e.git);
+
+ if (mergeSummary.failed) {
+   // deal with the error
+ }
+ ```
+ */
+export declare class GitResponseError<T = any> extends GitError {
+    /**
+     * `.git` access the parsed response that is treated as being an error
+     */
+    readonly git: T;
+    constructor(
+    /**
+     * `.git` access the parsed response that is treated as being an error
+     */
+    git: T, message?: string);
+}

package/dist/node_modules/simple-git/dist/src/lib/errors/task-configuration-error.d.ts

@@ -0,0 +1,12 @@
+import { GitError } from './git-error';
+/**
+ * The `TaskConfigurationError` is thrown when a command was incorrectly
+ * configured. An error of this kind means that no attempt was made to
+ * run your command through the underlying `git` binary.
+ *
+ * Check the `.message` property for more detail on why your configuration
+ * resulted in an error.
+ */
+export declare class TaskConfigurationError extends GitError {
+    constructor(message?: string);
+}

package/dist/node_modules/simple-git/dist/src/lib/git-factory.d.ts

@@ -0,0 +1,15 @@
+import { SimpleGitFactory } from '../../typings';
+import * as api from './api';
+import { SimpleGitOptions } from './types';
+/**
+ * Adds the necessary properties to the supplied object to enable it for use as
+ * the default export of a module.
+ *
+ * Eg: `module.exports = esModuleFactory({ something () {} })`
+ */
+export declare function esModuleFactory<T>(defaultExport: T): T & {
+    __esModule: true;
+    default: T;
+};
+export declare function gitExportFactory(factory: SimpleGitFactory): SimpleGitFactory & typeof api;
+export declare function gitInstanceFactory(baseDir?: string | Partial<SimpleGitOptions>, options?: Partial<SimpleGitOptions>): any;

package/dist/node_modules/simple-git/dist/src/lib/git-logger.d.ts

@@ -0,0 +1,21 @@
+import { Debugger } from 'debug';
+type OutputLoggingHandler = (message: string, ...args: any[]) => void;
+export interface OutputLogger extends OutputLoggingHandler {
+    readonly label: string;
+    info: OutputLoggingHandler;
+    step(nextStep?: string): OutputLogger;
+    sibling(name: string): OutputLogger;
+}
+export declare function createLogger(label: string, verbose?: string | Debugger, initialStep?: string, infoDebugger?: Debugger): OutputLogger;
+/**
+ * The `GitLogger` is used by the main `SimpleGit` runner to handle logging
+ * any warnings or errors.
+ */
+export declare class GitLogger {
+    private _out;
+    error: OutputLoggingHandler;
+    warn: OutputLoggingHandler;
+    constructor(_out?: Debugger);
+    silent(silence?: boolean): void;
+}
+export {};

package/dist/node_modules/simple-git/dist/src/lib/parsers/parse-branch-delete.d.ts

@@ -0,0 +1,5 @@
+import { BranchMultiDeleteResult } from '../../../typings';
+import { TaskParser } from '../types';
+import { ExitCodes } from '../utils';
+export declare const parseBranchDeletions: TaskParser<string, BranchMultiDeleteResult>;
+export declare function hasBranchDeletionError(data: string, processExitCode: ExitCodes): boolean;

package/dist/node_modules/simple-git/dist/src/lib/parsers/parse-branch.d.ts

@@ -0,0 +1,2 @@
+import type { BranchSummary } from '../../../typings';
+export declare function parseBranchSummary(stdOut: string, currentOnly?: boolean): BranchSummary;

package/dist/node_modules/simple-git/dist/src/lib/parsers/parse-commit.d.ts

@@ -0,0 +1,2 @@
+import { CommitResult } from '../../../typings';
+export declare function parseCommitResult(stdOut: string): CommitResult;

package/dist/node_modules/simple-git/dist/src/lib/parsers/parse-diff-summary.d.ts

@@ -0,0 +1,3 @@
+import { LogFormat } from '../args/log-format';
+import { DiffSummary } from '../responses/DiffSummary';
+export declare function getDiffParser(format?: LogFormat): (stdOut: string) => DiffSummary;

package/dist/node_modules/simple-git/dist/src/lib/parsers/parse-fetch.d.ts

@@ -0,0 +1,2 @@
+import { FetchResult } from '../../../typings';
+export declare function parseFetchResult(stdOut: string, stdErr: string): FetchResult;

package/dist/node_modules/simple-git/dist/src/lib/parsers/parse-list-log-summary.d.ts

@@ -0,0 +1,6 @@
+import { LogResult } from '../../../typings';
+import { LogFormat } from '../args/log-format';
+export declare const START_BOUNDARY = "\u00F2\u00F2\u00F2\u00F2\u00F2\u00F2 ";
+export declare const COMMIT_BOUNDARY = " \u00F2\u00F2";
+export declare const SPLITTER = " \u00F2 ";
+export declare function createListLogSummaryParser<T = any>(splitter?: string, fields?: string[], logFormat?: LogFormat): (stdOut: string) => LogResult<T>;

package/dist/node_modules/simple-git/dist/src/lib/parsers/parse-merge.d.ts

@@ -0,0 +1,11 @@
+import { MergeDetail, MergeResult } from '../../../typings';
+import { TaskParser } from '../types';
+/**
+ * Parse the complete response from `git.merge`
+ */
+export declare const parseMergeResult: TaskParser<string, MergeResult>;
+/**
+ * Parse the merge specific detail (ie: not the content also available in the pull detail) from `git.mnerge`
+ * @param stdOut
+ */
+export declare const parseMergeDetail: TaskParser<string, MergeDetail>;

package/dist/node_modules/simple-git/dist/src/lib/parsers/parse-move.d.ts

@@ -0,0 +1,2 @@
+import { MoveResult } from '../../../typings';
+export declare function parseMoveResult(stdOut: string): MoveResult;

package/dist/node_modules/simple-git/dist/src/lib/parsers/parse-pull.d.ts

@@ -0,0 +1,6 @@
+import { PullDetail, PullResult } from '../../../typings';
+import { PullFailedSummary } from '../responses/PullSummary';
+import { TaskParser } from '../types';
+export declare const parsePullDetail: TaskParser<string, PullDetail>;
+export declare const parsePullResult: TaskParser<string, PullResult>;
+export declare function parsePullErrorResult(stdOut: string, stdErr: string): "" | PullFailedSummary;

package/dist/node_modules/simple-git/dist/src/lib/parsers/parse-push.d.ts

@@ -0,0 +1,4 @@
+import { PushDetail, PushResult } from '../../../typings';
+import { TaskParser } from '../types';
+export declare const parsePushResult: TaskParser<string, PushResult>;
+export declare const parsePushDetail: TaskParser<string, PushDetail>;

package/dist/node_modules/simple-git/dist/src/lib/parsers/parse-remote-messages.d.ts

@@ -0,0 +1,5 @@
+import { RemoteMessageResult, RemoteMessages } from '../../../typings';
+export declare function parseRemoteMessages<T extends RemoteMessages = RemoteMessages>(_stdOut: string, stdErr: string): RemoteMessageResult;
+export declare class RemoteMessageSummary implements RemoteMessages {
+    readonly all: string[];
+}

package/dist/node_modules/simple-git/dist/src/lib/parsers/parse-remote-objects.d.ts

@@ -0,0 +1,3 @@
+import { RemoteMessageResult, RemoteMessages } from '../../../typings';
+import { RemoteLineParser } from '../utils';
+export declare const remoteMessagesObjectParsers: RemoteLineParser<RemoteMessageResult<RemoteMessages>>[];

package/dist/node_modules/simple-git/dist/src/lib/plugins/abort-plugin.d.ts

@@ -0,0 +1,3 @@
+import { SimpleGitOptions } from '../types';
+import { SimpleGitPlugin } from './simple-git-plugin';
+export declare function abortPlugin(signal: SimpleGitOptions['abort']): (SimpleGitPlugin<"spawn.before"> | SimpleGitPlugin<"spawn.after">)[] | undefined;

package/dist/node_modules/simple-git/dist/src/lib/plugins/block-unsafe-operations-plugin.d.ts

@@ -0,0 +1,3 @@
+import type { SimpleGitPluginConfig } from '../types';
+import type { SimpleGitPlugin } from './simple-git-plugin';
+export declare function blockUnsafeOperationsPlugin(options?: SimpleGitPluginConfig['unsafe']): SimpleGitPlugin<'spawn.args'>;

package/dist/node_modules/simple-git/dist/src/lib/plugins/command-config-prefixing-plugin.d.ts

@@ -0,0 +1,2 @@
+import { SimpleGitPlugin } from './simple-git-plugin';
+export declare function commandConfigPrefixingPlugin(configuration: string[]): SimpleGitPlugin<'spawn.args'>;

package/dist/node_modules/simple-git/dist/src/lib/plugins/completion-detection.plugin.d.ts

@@ -0,0 +1,3 @@
+import { SimpleGitPluginConfig } from '../types';
+import { SimpleGitPlugin } from './simple-git-plugin';
+export declare function completionDetectionPlugin({ onClose, onExit, }?: SimpleGitPluginConfig['completion']): SimpleGitPlugin<'spawn.after'>;

package/dist/node_modules/simple-git/dist/src/lib/plugins/custom-binary.plugin.d.ts

@@ -0,0 +1,3 @@
+import type { SimpleGitOptions } from '../types';
+import { PluginStore } from './plugin-store';
+export declare function customBinaryPlugin(plugins: PluginStore, input?: SimpleGitOptions['binary'], allowUnsafe?: boolean): void;

package/dist/node_modules/simple-git/dist/src/lib/plugins/error-detection.plugin.d.ts

@@ -0,0 +1,7 @@
+import { GitExecutorResult, SimpleGitPluginConfig } from '../types';
+import { SimpleGitPlugin } from './simple-git-plugin';
+type TaskResult = Omit<GitExecutorResult, 'rejection'>;
+declare function isTaskError(result: TaskResult): boolean;
+export declare function errorDetectionHandler(overwrite?: boolean, isError?: typeof isTaskError, errorMessage?: (result: TaskResult) => Buffer | Error): (error: Buffer | Error | undefined, result: TaskResult) => Error | Buffer<ArrayBufferLike> | undefined;
+export declare function errorDetectionPlugin(config: SimpleGitPluginConfig['errors']): SimpleGitPlugin<'task.error'>;
+export {};

package/dist/node_modules/simple-git/dist/src/lib/plugins/index.d.ts

@@ -0,0 +1,11 @@
+export * from './abort-plugin';
+export { blockUnsafeOperationsPlugin } from './block-unsafe-operations-plugin';
+export * from './command-config-prefixing-plugin';
+export * from './completion-detection.plugin';
+export * from './custom-binary.plugin';
+export * from './error-detection.plugin';
+export * from './plugin-store';
+export * from './progress-monitor-plugin';
+export * from './simple-git-plugin';
+export * from './spawn-options-plugin';
+export * from './timout-plugin';

package/dist/node_modules/simple-git/dist/src/lib/plugins/plugin-store.d.ts

@@ -0,0 +1,11 @@
+import type { SimpleGitPlugin, SimpleGitPluginType, SimpleGitPluginTypes } from './simple-git-plugin';
+import type { SimpleGitPluginConfig } from '../types';
+export declare class PluginStore {
+    private plugins;
+    private events;
+    on<K extends keyof SimpleGitPluginConfig>(type: K, listener: (data: SimpleGitPluginConfig[K]) => void): void;
+    reconfigure<K extends keyof SimpleGitPluginConfig>(type: K, data: SimpleGitPluginConfig[K]): void;
+    append<T extends SimpleGitPluginType>(type: T, action: SimpleGitPlugin<T>['action']): () => boolean;
+    add<T extends SimpleGitPluginType>(plugin: void | SimpleGitPlugin<T> | SimpleGitPlugin<T>[]): () => void;
+    exec<T extends SimpleGitPluginType>(type: T, data: SimpleGitPluginTypes[T]['data'], context: SimpleGitPluginTypes[T]['context']): typeof data;
+}

package/dist/node_modules/simple-git/dist/src/lib/plugins/progress-monitor-plugin.d.ts

@@ -0,0 +1,3 @@
+import { SimpleGitOptions } from '../types';
+import { SimpleGitPlugin } from './simple-git-plugin';
+export declare function progressMonitorPlugin(progress: Exclude<SimpleGitOptions['progress'], void>): (SimpleGitPlugin<"spawn.after"> | SimpleGitPlugin<"spawn.args">)[];

package/dist/node_modules/simple-git/dist/src/lib/plugins/simple-git-plugin.d.ts

@@ -0,0 +1,48 @@
+import { ChildProcess, SpawnOptions } from 'child_process';
+import { GitExecutorResult } from '../types';
+type SimpleGitTaskPluginContext = {
+    readonly method: string;
+    readonly commands: string[];
+};
+export interface SimpleGitPluginTypes {
+    'spawn.args': {
+        data: string[];
+        context: SimpleGitTaskPluginContext & {
+            env: Record<string, string | undefined>;
+        };
+    };
+    'spawn.binary': {
+        data: string;
+        context: SimpleGitTaskPluginContext & {};
+    };
+    'spawn.options': {
+        data: Partial<SpawnOptions>;
+        context: SimpleGitTaskPluginContext & {};
+    };
+    'spawn.before': {
+        data: void;
+        context: SimpleGitTaskPluginContext & {
+            kill(reason: Error): void;
+        };
+    };
+    'spawn.after': {
+        data: void;
+        context: SimpleGitTaskPluginContext & {
+            spawned: ChildProcess;
+            close(exitCode: number, reason?: Error): void;
+            kill(reason: Error): void;
+        };
+    };
+    'task.error': {
+        data: {
+            error?: Error;
+        };
+        context: SimpleGitTaskPluginContext & GitExecutorResult;
+    };
+}
+export type SimpleGitPluginType = keyof SimpleGitPluginTypes;
+export interface SimpleGitPlugin<T extends SimpleGitPluginType> {
+    action(data: SimpleGitPluginTypes[T]['data'], context: SimpleGitPluginTypes[T]['context']): typeof data;
+    type: T;
+}
+export {};

package/dist/node_modules/simple-git/dist/src/lib/plugins/spawn-options-plugin.d.ts

@@ -0,0 +1,3 @@
+import { SpawnOptions } from 'child_process';
+import { SimpleGitPlugin } from './simple-git-plugin';
+export declare function spawnOptionsPlugin(spawnOptions: Partial<SpawnOptions>): SimpleGitPlugin<'spawn.options'>;

package/dist/node_modules/simple-git/dist/src/lib/plugins/suffix-paths.plugin.d.ts

@@ -0,0 +1,2 @@
+import { SimpleGitPlugin } from './simple-git-plugin';
+export declare function suffixPathsPlugin(): SimpleGitPlugin<'spawn.args'>;

package/dist/node_modules/simple-git/dist/src/lib/plugins/timout-plugin.d.ts

@@ -0,0 +1,3 @@
+import type { SimpleGitPlugin } from './simple-git-plugin';
+import type { SimpleGitOptions } from '../types';
+export declare function timeoutPlugin({ block, stdErr, stdOut, }: Exclude<SimpleGitOptions['timeout'], undefined>): SimpleGitPlugin<'spawn.after'> | void;

package/dist/node_modules/simple-git/dist/src/lib/responses/BranchDeleteSummary.d.ts

@@ -0,0 +1,12 @@
+import { BranchMultiDeleteResult, BranchSingleDeleteFailure, BranchSingleDeleteResult, BranchSingleDeleteSuccess } from '../../../typings';
+export declare class BranchDeletionBatch implements BranchMultiDeleteResult {
+    all: BranchSingleDeleteResult[];
+    branches: {
+        [branchName: string]: BranchSingleDeleteResult;
+    };
+    errors: BranchSingleDeleteResult[];
+    get success(): boolean;
+}
+export declare function branchDeletionSuccess(branch: string, hash: string): BranchSingleDeleteSuccess;
+export declare function branchDeletionFailure(branch: string): BranchSingleDeleteFailure;
+export declare function isSingleBranchDeleteFailure(test: BranchSingleDeleteResult): test is BranchSingleDeleteSuccess;

package/dist/node_modules/simple-git/dist/src/lib/responses/BranchSummary.d.ts

@@ -0,0 +1,14 @@
+import type { BranchSummary, BranchSummaryBranch } from '../../../typings';
+export declare enum BranchStatusIdentifier {
+    CURRENT = "*",
+    LINKED = "+"
+}
+export declare class BranchSummaryResult implements BranchSummary {
+    all: string[];
+    branches: {
+        [p: string]: BranchSummaryBranch;
+    };
+    current: string;
+    detached: boolean;
+    push(status: BranchStatusIdentifier | unknown, detached: boolean, name: string, commit: string, label: string): void;
+}

package/dist/node_modules/simple-git/dist/src/lib/responses/CheckIgnore.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Parser for the `check-ignore` command - returns each file as a string array
+ */
+export declare const parseCheckIgnore: (text: string) => string[];

package/dist/node_modules/simple-git/dist/src/lib/responses/CleanSummary.d.ts

@@ -0,0 +1,9 @@
+import { CleanSummary } from '../../../typings';
+export declare class CleanResponse implements CleanSummary {
+    readonly dryRun: boolean;
+    paths: string[];
+    files: string[];
+    folders: string[];
+    constructor(dryRun: boolean);
+}
+export declare function cleanSummaryParser(dryRun: boolean, text: string): CleanSummary;

package/dist/node_modules/simple-git/dist/src/lib/responses/ConfigList.d.ts

@@ -0,0 +1,13 @@
+import { ConfigGetResult, ConfigListSummary, ConfigValues } from '../../../typings';
+export declare class ConfigList implements ConfigListSummary {
+    files: string[];
+    values: {
+        [fileName: string]: ConfigValues;
+    };
+    private _all;
+    get all(): ConfigValues;
+    addFile(file: string): ConfigValues;
+    addValue(file: string, key: string, value: string): void;
+}
+export declare function configListParser(text: string): ConfigList;
+export declare function configGetParser(text: string, key: string): ConfigGetResult;

package/dist/node_modules/simple-git/dist/src/lib/responses/DiffSummary.d.ts

@@ -0,0 +1,10 @@
+import { DiffResult, DiffResultBinaryFile, DiffResultTextFile } from '../../../typings';
+/***
+ * The DiffSummary is returned as a response to getting `git().status()`
+ */
+export declare class DiffSummary implements DiffResult {
+    changed: number;
+    deletions: number;
+    insertions: number;
+    files: Array<DiffResultTextFile | DiffResultBinaryFile>;
+}

package/dist/node_modules/simple-git/dist/src/lib/responses/FileStatusSummary.d.ts

@@ -0,0 +1,9 @@
+import { FileStatusResult } from '../../../typings';
+export declare const fromPathRegex: RegExp;
+export declare class FileStatusSummary implements FileStatusResult {
+    path: string;
+    index: string;
+    working_dir: string;
+    readonly from: string | undefined;
+    constructor(path: string, index: string, working_dir: string);
+}

package/dist/node_modules/simple-git/dist/src/lib/responses/GetRemoteSummary.d.ts

@@ -0,0 +1,11 @@
+export interface RemoteWithoutRefs {
+    name: string;
+}
+export interface RemoteWithRefs extends RemoteWithoutRefs {
+    refs: {
+        fetch: string;
+        push: string;
+    };
+}
+export declare function parseGetRemotes(text: string): RemoteWithoutRefs[];
+export declare function parseGetRemotesVerbose(text: string): RemoteWithRefs[];

package/dist/node_modules/simple-git/dist/src/lib/responses/InitSummary.d.ts

@@ -0,0 +1,9 @@
+import { InitResult } from '../../../typings';
+export declare class InitSummary implements InitResult {
+    readonly bare: boolean;
+    readonly path: string;
+    readonly existing: boolean;
+    readonly gitDir: string;
+    constructor(bare: boolean, path: string, existing: boolean, gitDir: string);
+}
+export declare function parseInit(bare: boolean, path: string, text: string): InitSummary;

package/dist/node_modules/simple-git/dist/src/lib/responses/MergeSummary.d.ts

@@ -0,0 +1,16 @@
+import { MergeConflict, MergeConflictDeletion, MergeDetail, MergeResultStatus } from '../../../typings';
+export declare class MergeSummaryConflict implements MergeConflict {
+    readonly reason: string;
+    readonly file: string | null;
+    readonly meta?: MergeConflictDeletion | undefined;
+    constructor(reason: string, file?: string | null, meta?: MergeConflictDeletion | undefined);
+    toString(): string;
+}
+export declare class MergeSummaryDetail implements MergeDetail {
+    conflicts: MergeConflict[];
+    merges: string[];
+    result: MergeResultStatus;
+    get failed(): boolean;
+    get reason(): string;
+    toString(): string;
+}

package/dist/node_modules/simple-git/dist/src/lib/responses/PullSummary.d.ts

@@ -0,0 +1,25 @@
+import { PullDetailFileChanges, PullDetailSummary, PullFailedResult, PullResult } from '../../../typings';
+export declare class PullSummary implements PullResult {
+    remoteMessages: {
+        all: never[];
+    };
+    created: never[];
+    deleted: string[];
+    files: string[];
+    deletions: PullDetailFileChanges;
+    insertions: PullDetailFileChanges;
+    summary: PullDetailSummary;
+}
+export declare class PullFailedSummary implements PullFailedResult {
+    remote: string;
+    hash: {
+        local: string;
+        remote: string;
+    };
+    branch: {
+        local: string;
+        remote: string;
+    };
+    message: string;
+    toString(): string;
+}

package/dist/node_modules/simple-git/dist/src/lib/responses/StatusSummary.d.ts

@@ -0,0 +1,19 @@
+import { StatusResult } from '../../../typings';
+export declare class StatusSummary implements StatusResult {
+    not_added: never[];
+    conflicted: never[];
+    created: never[];
+    deleted: never[];
+    ignored: undefined;
+    modified: never[];
+    renamed: never[];
+    files: never[];
+    staged: never[];
+    ahead: number;
+    behind: number;
+    current: null;
+    tracking: null;
+    detached: boolean;
+    isClean: () => boolean;
+}
+export declare const parseStatusSummary: (text: string) => StatusResult;

package/dist/node_modules/simple-git/dist/src/lib/responses/TagList.d.ts

@@ -0,0 +1,7 @@
+import { TagResult } from '../../../typings';
+export declare class TagList implements TagResult {
+    readonly all: string[];
+    readonly latest: string | undefined;
+    constructor(all: string[], latest: string | undefined);
+}
+export declare const parseTagList: (data: string, customSort?: boolean) => TagList;

package/dist/node_modules/simple-git/dist/src/lib/runners/git-executor-chain.d.ts

@@ -0,0 +1,25 @@
+import { PluginStore } from '../plugins';
+import { outputHandler, SimpleGitExecutor, SimpleGitTask } from '../types';
+import { Scheduler } from './scheduler';
+export declare class GitExecutorChain implements SimpleGitExecutor {
+    private _executor;
+    private _scheduler;
+    private _plugins;
+    private _chain;
+    private _queue;
+    private _cwd;
+    get cwd(): string;
+    set cwd(cwd: string);
+    get env(): import("../types").GitExecutorEnv;
+    get outputHandler(): outputHandler | undefined;
+    constructor(_executor: SimpleGitExecutor, _scheduler: Scheduler, _plugins: PluginStore);
+    chain(): this;
+    push<R>(task: SimpleGitTask<R>): Promise<R>;
+    private attemptTask;
+    private onFatalException;
+    private attemptRemoteTask;
+    private attemptEmptyTask;
+    private handleTaskData;
+    private gitResponse;
+    private _beforeSpawn;
+}

package/dist/node_modules/simple-git/dist/src/lib/runners/git-executor.d.ts

@@ -0,0 +1,14 @@
+import type { PluginStore } from '../plugins';
+import type { GitExecutorEnv, outputHandler, SimpleGitExecutor, SimpleGitTask } from '../types';
+import { Scheduler } from './scheduler';
+export declare class GitExecutor implements SimpleGitExecutor {
+    cwd: string;
+    private _scheduler;
+    private _plugins;
+    private _chain;
+    env: GitExecutorEnv;
+    outputHandler?: outputHandler;
+    constructor(cwd: string, _scheduler: Scheduler, _plugins: PluginStore);
+    chain(): SimpleGitExecutor;
+    push<R>(task: SimpleGitTask<R>): Promise<R>;
+}

package/dist/node_modules/simple-git/dist/src/lib/runners/promise-wrapped.d.ts

@@ -0,0 +1,2 @@
+import { SimpleGit, SimpleGitOptions } from '../../../typings';
+export declare function gitP(...args: [] | [string] | [Partial<SimpleGitOptions>] | [string, Partial<SimpleGitOptions>]): SimpleGit;

package/dist/node_modules/simple-git/dist/src/lib/runners/scheduler.d.ts

@@ -0,0 +1,11 @@
+type ScheduleCompleteCallback = () => void;
+export declare class Scheduler {
+    private concurrency;
+    private logger;
+    private pending;
+    private running;
+    constructor(concurrency?: number);
+    private schedule;
+    next(): Promise<ScheduleCompleteCallback>;
+}
+export {};