@shopify/cli-kit 0.33.7 → 1.0.4

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';
 
@@ -29,12 +31,12 @@ declare class Subscription implements SubscriptionLike {
     closed: boolean;
     private _parentage;
     /**
-     * The list of registered teardowns to execute upon unsubscription. Adding and removing from this
+     * The list of registered finalizers to execute upon unsubscription. Adding and removing from this
      * list occurs in the {@link #add} and {@link #remove} methods.
      */
-    private _teardowns;
+    private _finalizers;
     /**
-     * @param initialTeardown A function executed first as part of the teardown
+     * @param initialTeardown A function executed first as part of the finalization
      * process that is kicked off when {@link #unsubscribe} is called.
      */
     constructor(initialTeardown?: (() => void) | undefined);
@@ -46,12 +48,12 @@ declare class Subscription implements SubscriptionLike {
      */
     unsubscribe(): void;
     /**
-     * Adds a teardown to this subscription, so that teardown will be unsubscribed/called
+     * Adds a finalizer to this subscription, so that finalization will be unsubscribed/called
      * when this subscription is unsubscribed. If this subscription is already {@link #closed},
-     * because it has already been unsubscribed, then whatever teardown is passed to it
-     * will automatically be executed (unless the teardown itself is also a closed subscription).
+     * because it has already been unsubscribed, then whatever finalizer is passed to it
+     * will automatically be executed (unless the finalizer itself is also a closed subscription).
      *
-     * Closed Subscriptions cannot be added as teardowns to any subscription. Adding a closed
+     * Closed Subscriptions cannot be added as finalizers to any subscription. Adding a closed
      * subscription to a any subscription will result in no operation. (A noop).
      *
      * Adding a subscription to itself, or adding `null` or `undefined` will not perform any
@@ -61,7 +63,7 @@ declare class Subscription implements SubscriptionLike {
      * if they are unsubscribed. Functions and {@link Unsubscribable} objects that you wish to remove
      * will need to be removed manually with {@link #remove}
      *
-     * @param teardown The teardown logic to add to this subscription.
+     * @param teardown The finalization logic to add to this subscription.
      */
     add(teardown: TeardownLogic): void;
     /**
@@ -84,18 +86,18 @@ declare class Subscription implements SubscriptionLike {
      */
     private _removeParent;
     /**
-     * Removes a teardown from this subscription that was previously added with the {@link #add} method.
+     * Removes a finalizer from this subscription that was previously added with the {@link #add} method.
      *
      * Note that `Subscription` instances, when unsubscribed, will automatically remove themselves
      * from every other `Subscription` they have been added to. This means that using the `remove` method
      * is not a common thing and should be used thoughtfully.
      *
-     * If you add the same teardown instance of a function or an unsubscribable object to a `Subcription` instance
+     * If you add the same finalizer instance of a function or an unsubscribable object to a `Subcription` instance
      * more than once, you will need to call `remove` the same number of times to remove all instances.
      *
-     * All teardown instances are removed to free up memory upon unsubscription.
+     * All finalizer instances are removed to free up memory upon unsubscription.
      *
-     * @param teardown The teardown to remove from this subscription
+     * @param teardown The finalizer to remove from this subscription
      */
     remove(teardown: Exclude<TeardownLogic, void>): void;
 }
@@ -342,6 +344,7 @@ declare class Observable<T> implements Subscribable<T> {
  */
 declare class Subject<T> extends Observable<T> implements SubscriptionLike {
     closed: boolean;
+    private currentObservers;
     /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
     observers: Observer<T>[];
     /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
@@ -1433,6 +1436,9 @@ declare class Fatal extends Error {
  */
 declare class Abort extends Fatal {
 }
+declare class AbortSilent extends Fatal {
+    constructor();
+}
 /**
  * A bug error is an error that represents a bug and therefore should be reported.
  */
@@ -1449,6 +1455,8 @@ type error$1_Fatal = Fatal;
 declare const error$1_Fatal: typeof Fatal;
 type error$1_Abort = Abort;
 declare const error$1_Abort: typeof Abort;
+type error$1_AbortSilent = AbortSilent;
+declare const error$1_AbortSilent: typeof AbortSilent;
 type error$1_Bug = Bug;
 declare const error$1_Bug: typeof Bug;
 declare const error$1_handler: typeof handler;
@@ -1456,13 +1464,189 @@ declare namespace error$1 {
   export {
     error$1_Fatal as Fatal,
     error$1_Abort as Abort,
+    error$1_AbortSilent as AbortSilent,
     error$1_Bug as Bug,
     error$1_handler as handler,
   };
 }
 
+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;
+    env?: any;
     stdout?: Writable;
     stderr?: Writable;
 }
@@ -1474,7 +1658,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;
@@ -1489,7 +1673,7 @@ declare namespace system {
   };
 }
 
-declare function create(templateContent: string): (data: object) => Promise<string>;
+declare function create$1(templateContent: string): (data: object) => Promise<string>;
 /**
  * Given a directory, it traverses the files and directories recursively
  * and replaces variables in directory and file names, and files' content
@@ -1501,27 +1685,26 @@ declare function create(templateContent: string): (data: object) => Promise<stri
  */
 declare function recursiveDirectoryCopy(from: string, to: string, data: any): Promise<void>;
 
-declare const template_create: typeof create;
 declare const template_recursiveDirectoryCopy: typeof recursiveDirectoryCopy;
 declare namespace template {
   export {
-    template_create as create,
+    create$1 as create,
     template_recursiveDirectoryCopy as recursiveDirectoryCopy,
   };
 }
 
-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 +1740,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 +1773,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 +1809,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 +1829,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 +1884,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.
      *
@@ -1837,159 +2020,1567 @@ declare type Options$1 = {
     unique?: boolean;
 };
 
-declare type Task = {
-    base: string;
-    dynamic: boolean;
-    patterns: Pattern[];
-    positive: Pattern[];
-    negative: Pattern[];
-};
+declare type Task = {
+    base: string;
+    dynamic: boolean;
+    patterns: Pattern[];
+    positive: Pattern[];
+    negative: Pattern[];
+};
+
+declare type EntryObjectModePredicate = {
+    [TKey in keyof Pick<Options$2, 'objectMode'>]-?: true;
+};
+declare type EntryStatsPredicate = {
+    [TKey in keyof Pick<Options$2, 'stats'>]-?: true;
+};
+declare type EntryObjectPredicate = EntryObjectModePredicate | EntryStatsPredicate;
+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$2;
+    type Entry = Entry;
+    type Task = Task;
+    type Pattern = Pattern;
+    type FileSystemAdapter = FileSystemAdapter;
+    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;
+}
+
+declare const path_findUp: typeof findUp;
+declare const path_basename: typeof basename;
+declare const path_delimiter: typeof delimiter;
+declare const path_dirname: typeof dirname;
+declare const path_extname: typeof extname;
+declare const path_format: typeof format;
+declare const path_isAbsolute: typeof isAbsolute;
+declare const path_join: typeof join;
+declare const path_normalize: typeof normalize;
+declare const path_normalizeString: typeof normalizeString;
+declare const path_parse: typeof parse;
+declare const path_relative: typeof relative;
+declare const path_resolve: typeof resolve;
+declare const path_sep: typeof sep;
+declare const path_toNamespacedPath: typeof toNamespacedPath;
+declare namespace path {
+  export {
+    path_findUp as findUp,
+    FastGlob as glob,
+    path_basename as basename,
+    path_delimiter as delimiter,
+    path_dirname as dirname,
+    path_extname as extname,
+    path_format as format,
+    path_isAbsolute as isAbsolute,
+    path_join as join,
+    path_normalize as normalize,
+    path_normalizeString as normalizeString,
+    path_parse as parse,
+    path_relative as relative,
+    path_resolve as resolve,
+    path_sep as sep,
+    path_toNamespacedPath as toNamespacedPath,
+  };
+}
+
+/**
+ * Creates a temporary directory and ties its lifecycle ot the lifecycle of the callback.
+ * @param callback - The callback that receives the temporary directory.
+ */
+declare function inTemporaryDirectory<T>(callback: (tmpDir: string) => T | Promise<T>): Promise<T>;
+/**
+ * It reads a file and returns its content as a string using the
+ * utf-8 encoding
+ * @param path {string} Path to the file to read.
+ * @returns {Promise<string>} A promise that resolves with the content of the file.
+ */
+declare function read(path: string): Promise<string>;
+/**
+ * Copies a file
+ * @param from {string} Path to the directory or file to be copied.
+ * @param to {string} Destination path.
+ */
+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 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>;
+/**
+ * Moves a file.
+ * @param src {string} File to be moved.
+ * @param dest {string} Path to be moved to.
+ * @param options {object} Moving options.
+ */
+declare function move(src: string, dest: string, options?: {
+    overwrite?: boolean;
+}): Promise<void>;
+/**
+ * Changes the permissions of a directory or file.
+ * @param path {string} Path to the file or directory whose permissions will be modified.
+ * @param mode {string | numbers} Permissions to set to the file or directory.
+ */
+declare function chmod(path: string, mode: number | string): Promise<void>;
+/**
+ * Checks if a file has executable permissions.
+ * @param path {string} Path to the file whose permissions will be checked.
+ */
+declare function hasExecutablePermissions(path: string): Promise<boolean>;
+/**
+ * Returns true if a file or directory exists
+ * @param path {string} Path to the directory or file.
+ * @returns {boolean} True if it exists.
+ */
+declare function exists(path: string): Promise<boolean>;
+
+declare const file_inTemporaryDirectory: typeof inTemporaryDirectory;
+declare const file_read: typeof read;
+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;
+declare const file_move: typeof move;
+declare const file_chmod: typeof chmod;
+declare const file_hasExecutablePermissions: typeof hasExecutablePermissions;
+declare const file_exists: typeof exists;
+declare namespace file {
+  export {
+    file_inTemporaryDirectory as inTemporaryDirectory,
+    file_read as read,
+    file_copy as copy,
+    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,
+    file_move as move,
+    file_chmod as chmod,
+    file_hasExecutablePermissions as hasExecutablePermissions,
+    file_exists as exists,
+  };
+}
+
+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[]>;
 
-declare type EntryObjectModePredicate = {
-    [TKey in keyof Pick<Options$1, 'objectMode'>]-?: true;
-};
-declare type EntryStatsPredicate = {
-    [TKey in keyof Pick<Options$1, '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 namespace FastGlob {
-    type Options = Options$1;
-    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 escapePath(source: Pattern): Pattern;
-}
+   getRemotes(verbose: true, callback?: SimpleGitTaskCallback<RemoteWithRefs[]>): Response$2<RemoteWithRefs[]>;
 
-declare const path_findUp: typeof findUp;
-declare const path_basename: typeof basename;
-declare const path_delimiter: typeof delimiter;
-declare const path_dirname: typeof dirname;
-declare const path_extname: typeof extname;
-declare const path_format: typeof format;
-declare const path_isAbsolute: typeof isAbsolute;
-declare const path_join: typeof join;
-declare const path_normalize: typeof normalize;
-declare const path_normalizeString: typeof normalizeString;
-declare const path_parse: typeof parse;
-declare const path_relative: typeof relative;
-declare const path_resolve: typeof resolve;
-declare const path_sep: typeof sep;
-declare const path_toNamespacedPath: typeof toNamespacedPath;
-declare namespace path {
-  export {
-    path_findUp as findUp,
-    FastGlob as glob,
-    path_basename as basename,
-    path_delimiter as delimiter,
-    path_dirname as dirname,
-    path_extname as extname,
-    path_format as format,
-    path_isAbsolute as isAbsolute,
-    path_join as join,
-    path_normalize as normalize,
-    path_normalizeString as normalizeString,
-    path_parse as parse,
-    path_relative as relative,
-    path_resolve as resolve,
-    path_sep as sep,
-    path_toNamespacedPath as toNamespacedPath,
-  };
+   /**
+    * 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>;
 }
 
-/**
- * Creates a temporary directory and ties its lifecycle ot the lifecycle of the callback.
- * @param callback - The callback that receives the temporary directory.
- */
-declare function inTemporaryDirectory<T>(callback: (tmpDir: string) => T | Promise<T>): Promise<T>;
-/**
- * It reads a file and returns its content as a string using the
- * utf-8 encoding
- * @param path {string} Path to the file to read.
- * @returns {Promise<string>} A promise that resolves with the content of the file.
- */
-declare function read(path: string): Promise<string>;
-/**
- * Copies a file
- * @param from {string} Path to the directory or file to be copied.
- * @param to {string} Destination path.
- */
-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 mkTmpDir(): Promise<string>;
-declare function isDirectory(path: string): Promise<boolean>;
-/**
- * Moves a file.
- * @param src {string} File to be moved.
- * @param dest {string} Path to be moved to.
- * @param options {object} Moving options.
- */
-declare function move(src: string, dest: string, options?: {
-    overwrite?: boolean;
-}): Promise<void>;
-/**
- * Changes the permissions of a directory or file.
- * @param path {string} Path to the file or directory whose permissions will be modified.
- * @param mode {string | numbers} Permissions to set to the file or directory.
- */
-declare function chmod(path: string, mode: number | string): Promise<void>;
-/**
- * Checks if a file has executable permissions.
- * @param path {string} Path to the file whose permissions will be checked.
- */
-declare function hasExecutablePermissions(path: string): Promise<boolean>;
-/**
- * Returns true if a file or directory exists
- * @param path {string} Path to the directory or file.
- * @returns {boolean} True if it exists.
- */
-declare function exists(path: string): Promise<boolean>;
+declare const factory: SimpleGitFactory;
 
-declare const file_inTemporaryDirectory: typeof inTemporaryDirectory;
-declare const file_read: typeof read;
-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_rmdir: typeof rmdir;
-declare const file_mkTmpDir: typeof mkTmpDir;
-declare const file_isDirectory: typeof isDirectory;
-declare const file_move: typeof move;
-declare const file_chmod: typeof chmod;
-declare const file_hasExecutablePermissions: typeof hasExecutablePermissions;
-declare const file_exists: typeof exists;
-declare namespace file {
+declare const git_factory: typeof factory;
+declare namespace git {
   export {
-    file_inTemporaryDirectory as inTemporaryDirectory,
-    file_read as read,
-    file_copy as copy,
-    file_write as write,
-    file_append as append,
-    file_mkdir as mkdir,
-    file_rmdir as rmdir,
-    file_mkTmpDir as mkTmpDir,
-    file_isDirectory as isDirectory,
-    file_move as move,
-    file_chmod as chmod,
-    file_hasExecutablePermissions as hasExecutablePermissions,
-    file_exists as exists,
+    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 +3595,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;
@@ -2060,8 +3655,18 @@ declare const newline: () => void;
  */
 declare const error: (content: Fatal) => void;
 declare function stringifyMessage(message: Message): string;
+/**
+ * Use this function when you have multiple concurrent processes that send data events
+ * and we need to output them ensuring that they can visually differenciated by the user.
+ *
+ * @param index {number} The index of the process being run. This is used to determine the color.
+ * @param prefix {string} The prefix to include in the standard output data to differenciate logs.
+ * @param process The callback that's called with a Writable instance to send events through.
+ */
+declare function concurrent(index: number, prefix: string, callback: (stdout: Writable, stderr: Writable) => Promise<void>): Promise<void>;
 
 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;
@@ -2073,9 +3678,11 @@ declare const output$1_warn: typeof warn;
 declare const output$1_newline: typeof newline;
 declare const output$1_error: typeof error;
 declare const output$1_stringifyMessage: typeof stringifyMessage;
+declare const output$1_concurrent: typeof concurrent;
 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,
@@ -2087,6 +3694,7 @@ declare namespace output$1 {
     output$1_newline as newline,
     output$1_error as error,
     output$1_stringifyMessage as stringifyMessage,
+    output$1_concurrent as concurrent,
   };
 }
 
@@ -2106,9 +3714,10 @@ declare function dependencyManagerUsedForCreating(env?: NodeJS.ProcessEnv): Depe
  * Installs the dependencies in the given directory.
  * @param directory {string} The directory that contains the package.json
  * @param dependencyManager {DependencyManager} The dependency manager to use to install the dependencies.
- * @returns
+ * @param stdout {Writable} Standard output stream.
+ * @returns stderr {Writable} Standard error stream.
  */
-declare function install(directory: string, dependencyManager: DependencyManager, stdout?: Writable): Promise<void>;
+declare function install(directory: string, dependencyManager: DependencyManager, stdout?: Writable, stderr?: Writable): Promise<void>;
 
 type dependency_DependencyManager = DependencyManager;
 declare const dependency_DependencyManager: typeof DependencyManager;
@@ -2355,6 +3964,9 @@ declare namespace session {
   };
 }
 
+declare type Primitive = string | number | bigint | boolean | null | undefined;
+declare type Scalars = Primitive | Primitive[];
+
 declare namespace util {
     type AssertEqual<T, Expected> = [T] extends [Expected] ? [Expected] extends [T] ? true : false : false;
     function assertNever(_x: never): never;
@@ -2378,6 +3990,7 @@ declare const ZodIssueCode: {
     invalid_type: "invalid_type";
     custom: "custom";
     invalid_union: "invalid_union";
+    invalid_union_discriminator: "invalid_union_discriminator";
     invalid_enum_value: "invalid_enum_value";
     unrecognized_keys: "unrecognized_keys";
     invalid_arguments: "invalid_arguments";
@@ -2407,6 +4020,10 @@ interface ZodInvalidUnionIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_union;
     unionErrors: ZodError[];
 }
+interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union_discriminator;
+    options: Primitive[];
+}
 interface ZodInvalidEnumValueIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_enum_value;
     options: (string | number)[];
@@ -2431,13 +4048,13 @@ interface ZodTooSmallIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.too_small;
     minimum: number;
     inclusive: boolean;
-    type: "array" | "string" | "number";
+    type: "array" | "string" | "number" | "set";
 }
 interface ZodTooBigIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.too_big;
     maximum: number;
     inclusive: boolean;
-    type: "array" | "string" | "number";
+    type: "array" | "string" | "number" | "set";
 }
 interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_intersection_types;
@@ -2455,7 +4072,7 @@ interface ZodCustomIssue extends ZodIssueBase {
 declare type DenormalizedError = {
     [k: string]: DenormalizedError | string[];
 };
-declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodCustomIssue;
+declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodCustomIssue;
 declare type ZodIssue = ZodIssueOptionalMessage & {
     message: string;
 };
@@ -2478,7 +4095,13 @@ declare class ZodError<T = any> extends Error {
     get isEmpty(): boolean;
     addIssue: (sub: ZodIssue) => void;
     addIssues: (subs?: ZodIssue[]) => void;
-    flatten: <U = string>(mapper?: (issue: ZodIssue) => U) => {
+    flatten(mapper?: (issue: ZodIssue) => string): {
+        formErrors: string[];
+        fieldErrors: {
+            [k: string]: string[];
+        };
+    };
+    flatten<U>(mapper?: (issue: ZodIssue) => U): {
         formErrors: U[];
         fieldErrors: {
             [k: string]: U[];
@@ -2533,7 +4156,7 @@ declare const ZodParsedType: {
     set: "set";
 };
 declare type ZodParsedType = keyof typeof ZodParsedType;
-declare const getParsedType: (data: any, cache?: Map<any, "function" | "number" | "string" | "nan" | "integer" | "float" | "boolean" | "date" | "bigint" | "symbol" | "undefined" | "null" | "array" | "object" | "unknown" | "promise" | "void" | "never" | "map" | "set"> | undefined) => ZodParsedType;
+declare const getParsedType: (data: any) => ZodParsedType;
 declare const makeIssue: (params: {
     data: any;
     path: (string | number)[];
@@ -2549,13 +4172,15 @@ declare type ParsePathComponent = string | number;
 declare type ParsePath = ParsePathComponent[];
 declare const EMPTY_PATH: ParsePath;
 interface ParseContext {
+    readonly common: {
+        readonly issues: ZodIssue[];
+        readonly contextualErrorMap?: ZodErrorMap;
+        readonly async: boolean;
+        readonly typeCache: Map<any, ZodParsedType> | undefined;
+    };
     readonly path: ParsePath;
-    readonly issues: ZodIssue[];
     readonly schemaErrorMap?: ZodErrorMap;
-    readonly contextualErrorMap?: ZodErrorMap;
-    readonly async: boolean;
     readonly parent: ParseContext | null;
-    readonly typeCache: Map<any, ZodParsedType>;
     readonly data: any;
     readonly parsedType: ZodParsedType;
 }
@@ -2639,6 +4264,14 @@ declare type ZodTypeAny = ZodType<any, any, any>;
 declare type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
 declare type input<T extends ZodType<any, any, any>> = T["_input"];
 declare type output<T extends ZodType<any, any, any>> = T["_output"];
+declare type allKeys<T> = T extends any ? keyof T : never;
+declare type TypeOfFlattenedError<T extends ZodType<any, any, any>, U = string> = {
+    formErrors: U[];
+    fieldErrors: {
+        [P in allKeys<TypeOf<T>>]?: U[];
+    };
+};
+declare type TypeOfFormErrors<T extends ZodType<any, any, any>> = TypeOfFlattenedError<T>;
 
 declare type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
 interface ZodTypeDef {
@@ -2660,13 +4293,15 @@ declare type SafeParseError<Input> = {
     error: ZodError<Input>;
 };
 declare type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
-declare abstract class ZodType<Output, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
+declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
     readonly _type: Output;
     readonly _output: Output;
     readonly _input: Input;
     readonly _def: Def;
     get description(): string | undefined;
     abstract _parse(input: ParseInput): ParseReturnType<Output>;
+    _getType(input: ParseInput): string;
+    _getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;
     _processInputParams(input: ParseInput): {
         status: ParseStatus;
         ctx: ParseContext;
@@ -2679,10 +4314,6 @@ declare abstract class ZodType<Output, Def extends ZodTypeDef = ZodTypeDef, Inpu
     safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
     /** Alias of safeParseAsync */
     spa: (data: unknown, params?: Partial<ParseParams> | undefined) => Promise<SafeParseReturnType<Input, Output>>;
-    /** The .is method has been removed in Zod 3. For details see https://github.com/colinhacks/zod/tree/v3. */
-    is: never;
-    /** The .check method has been removed in Zod 3. For details see https://github.com/colinhacks/zod/tree/v3. */
-    check: never;
     refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, RefinedOutput>;
     refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
     refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, RefinedOutput>;
@@ -2899,7 +4530,9 @@ declare namespace objectUtil {
     type optionalKeys<T extends object> = {
         [k in keyof T]: undefined extends T[k] ? k : never;
     }[keyof T];
-    type requiredKeys<T extends object> = Exclude<keyof T, optionalKeys<T>>;
+    type requiredKeys<T extends object> = {
+        [k in keyof T]: undefined extends T[k] ? never : k;
+    }[keyof T];
     export type addQuestionMarks<T extends object> = {
         [k in optionalKeys<T>]?: T[k];
     } & {
@@ -2924,8 +4557,6 @@ declare type extendShape<A, B> = {
     [k in keyof B]: B[k];
 };
 declare type UnknownKeysParam = "passthrough" | "strict" | "strip";
-declare type Primitive = string | number | bigint | boolean | null | undefined;
-declare type Scalars = Primitive | Primitive[];
 interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodObject;
     shape: () => T;
@@ -3004,15 +4635,46 @@ declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysPa
     static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>[k_3]; }>;
 }
 declare type AnyZodObject = ZodObject<any, any, any>;
-declare type ZodUnionOptions = [ZodTypeAny, ...ZodTypeAny[]];
-interface ZodUnionDef<T extends ZodUnionOptions = [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]> extends ZodTypeDef {
+declare type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
+interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[
+    ZodTypeAny,
+    ZodTypeAny,
+    ...ZodTypeAny[]
+]>> extends ZodTypeDef {
     options: T;
     typeName: ZodFirstPartyTypeKind.ZodUnion;
 }
 declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get options(): T;
-    static create: <T_1 extends [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
+    static create: <T_1 extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
+}
+declare type ZodDiscriminatedUnionOption<Discriminator extends string, DiscriminatorValue extends Primitive> = ZodObject<{
+    [key in Discriminator]: ZodLiteral<DiscriminatorValue>;
+} & ZodRawShape, any, any>;
+interface ZodDiscriminatedUnionDef<Discriminator extends string, DiscriminatorValue extends Primitive, Option extends ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>> extends ZodTypeDef {
+    discriminator: Discriminator;
+    options: Map<DiscriminatorValue, Option>;
+    typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
+}
+declare class ZodDiscriminatedUnion<Discriminator extends string, DiscriminatorValue extends Primitive, Option extends ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>> extends ZodType<Option["_output"], ZodDiscriminatedUnionDef<Discriminator, DiscriminatorValue, Option>, Option["_input"]> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    get discriminator(): Discriminator;
+    get validDiscriminatorValues(): DiscriminatorValue[];
+    get options(): Map<DiscriminatorValue, Option>;
+    /**
+     * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
+     * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
+     * have a different value for each object in the union.
+     * @param discriminator the name of the discriminator property
+     * @param types an array of object schemas
+     * @param params
+     */
+    static create<Discriminator extends string, DiscriminatorValue extends Primitive, Types extends [
+        ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>,
+        ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>,
+        ...ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>[]
+    ]>(discriminator: Discriminator, types: Types, params?: RawCreateParams): ZodDiscriminatedUnion<Discriminator, DiscriminatorValue, Types[number]>;
 }
 interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     left: T;
@@ -3024,7 +4686,7 @@ declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extend
     static create: <T_1 extends ZodTypeAny, U_1 extends ZodTypeAny>(left: T_1, right: U_1, params?: RawCreateParams) => ZodIntersection<T_1, U_1>;
 }
 declare type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
-declare type AssertArray<T extends any> = T extends any[] ? T : never;
+declare type AssertArray<T> = T extends any[] ? T : never;
 declare type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
     [k in keyof T]: T[k] extends ZodType<any, any> ? T[k]["_output"] : never;
 }>;
@@ -3050,7 +4712,8 @@ interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeA
     typeName: ZodFirstPartyTypeKind.ZodRecord;
 }
 declare type KeySchema = ZodType<string | number | symbol, any, any>;
-declare class ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Record<Key["_output"], Value["_output"]>, ZodRecordDef<Key, Value>, Record<Key["_input"], Value["_input"]>> {
+declare type RecordType<K extends string | number | symbol, V> = [string] extends [K] ? Record<K, V> : [number] extends [K] ? Record<K, V> : [symbol] extends [K] ? Record<K, V> : Partial<Record<K, V>>;
+declare class ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<RecordType<Key["_output"], Value["_output"]>, ZodRecordDef<Key, Value>, RecordType<Key["_input"], Value["_input"]>> {
     get keySchema(): Key;
     get valueSchema(): Value;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
@@ -3070,9 +4733,21 @@ declare class ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeA
 interface ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     valueType: Value;
     typeName: ZodFirstPartyTypeKind.ZodSet;
+    minSize: {
+        value: number;
+        message?: string;
+    } | null;
+    maxSize: {
+        value: number;
+        message?: string;
+    } | null;
 }
 declare class ZodSet<Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Set<Value["_output"]>, ZodSetDef<Value>, Set<Value["_input"]>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    min(minSize: number, message?: errorUtil.ErrMessage): this;
+    max(maxSize: number, message?: errorUtil.ErrMessage): this;
+    size(size: number, message?: errorUtil.ErrMessage): this;
+    nonempty(message?: errorUtil.ErrMessage): ZodSet<Value>;
     static create: <Value_1 extends ZodTypeAny = ZodTypeAny>(valueType: Value_1, params?: RawCreateParams) => ZodSet<Value_1>;
 }
 interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
@@ -3102,11 +4777,11 @@ declare class ZodLazy<T extends ZodTypeAny> extends ZodType<output<T>, ZodLazyDe
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     static create: <T_1 extends ZodTypeAny>(getter: () => T_1, params?: RawCreateParams) => ZodLazy<T_1>;
 }
-interface ZodLiteralDef<T extends any = any> extends ZodTypeDef {
+interface ZodLiteralDef<T = any> extends ZodTypeDef {
     value: T;
     typeName: ZodFirstPartyTypeKind.ZodLiteral;
 }
-declare class ZodLiteral<T extends any> extends ZodType<T, ZodLiteralDef<T>> {
+declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get value(): T;
     static create: <T_1 extends Primitive>(value: T_1, params?: RawCreateParams) => ZodLiteral<T_1>;
@@ -3144,6 +4819,7 @@ declare type EnumLike = {
 };
 declare class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T], ZodNativeEnumDef<T>> {
     _parse(input: ParseInput): ParseReturnType<T[keyof T]>;
+    get enum(): T;
     static create: <T_1 extends EnumLike>(values: T_1, params?: RawCreateParams) => ZodNativeEnum<T_1>;
 }
 interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
@@ -3211,6 +4887,13 @@ declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<
     removeDefault(): T;
     static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodOptional<T_1>;
 }
+interface ZodNaNDef extends ZodTypeDef {
+    typeName: ZodFirstPartyTypeKind.ZodNaN;
+}
+declare class ZodNaN extends ZodType<number, ZodNaNDef> {
+    _parse(input: ParseInput): ParseReturnType<any>;
+    static create: (params?: RawCreateParams) => ZodNaN;
+}
 declare const custom: <T>(check?: ((data: unknown) => any) | undefined, params?: Parameters<ZodTypeAny["refine"]>[1]) => ZodType<T, ZodTypeDef, T>;
 
 declare const late: {
@@ -3219,6 +4902,7 @@ declare const late: {
 declare enum ZodFirstPartyTypeKind {
     ZodString = "ZodString",
     ZodNumber = "ZodNumber",
+    ZodNaN = "ZodNaN",
     ZodBigInt = "ZodBigInt",
     ZodBoolean = "ZodBoolean",
     ZodDate = "ZodDate",
@@ -3231,6 +4915,7 @@ declare enum ZodFirstPartyTypeKind {
     ZodArray = "ZodArray",
     ZodObject = "ZodObject",
     ZodUnion = "ZodUnion",
+    ZodDiscriminatedUnion = "ZodDiscriminatedUnion",
     ZodIntersection = "ZodIntersection",
     ZodTuple = "ZodTuple",
     ZodRecord = "ZodRecord",
@@ -3247,10 +4932,11 @@ declare enum ZodFirstPartyTypeKind {
     ZodDefault = "ZodDefault",
     ZodPromise = "ZodPromise"
 }
-declare type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any, any, any> | ZodUnion<any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodPromise<any>;
+declare type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any, any, any> | ZodUnion<any> | ZodDiscriminatedUnion<any, any, any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodPromise<any>;
 declare const instanceOfType: <T extends new (...args: any[]) => any>(cls: T, params?: Parameters<ZodTypeAny["refine"]>[1]) => ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>;
 declare const stringType: (params?: RawCreateParams) => ZodString;
 declare const numberType: (params?: RawCreateParams) => ZodNumber;
+declare const nanType: (params?: RawCreateParams) => ZodNaN;
 declare const bigIntType: (params?: RawCreateParams) => ZodBigInt;
 declare const booleanType: (params?: RawCreateParams) => ZodBoolean;
 declare const dateType: (params?: RawCreateParams) => ZodDate;
@@ -3263,7 +4949,8 @@ declare const voidType: (params?: RawCreateParams) => ZodVoid;
 declare const arrayType: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodArray<T, "many">;
 declare const objectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>[k_3]; }>;
 declare const strictObjectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strict", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>[k_3]; }>;
-declare const unionType: <T extends [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T, params?: RawCreateParams) => ZodUnion<T>;
+declare const unionType: <T extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T, params?: RawCreateParams) => ZodUnion<T>;
+declare const discriminatedUnionType: typeof ZodDiscriminatedUnion.create;
 declare const intersectionType: <T extends ZodTypeAny, U extends ZodTypeAny>(left: T, right: U, params?: RawCreateParams) => ZodIntersection<T, U>;
 declare const tupleType: <T extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: T, params?: RawCreateParams) => ZodTuple<T, null>;
 declare const recordType: typeof ZodRecord.create;
@@ -3283,225 +4970,241 @@ declare const ostring: () => ZodOptional<ZodString>;
 declare const onumber: () => ZodOptional<ZodNumber>;
 declare const oboolean: () => ZodOptional<ZodBoolean>;
 
-//# sourceMappingURL=external.d.ts.map
-
-type external_d_ZodParsedType = ZodParsedType;
-declare const external_d_getParsedType: typeof getParsedType;
-declare const external_d_makeIssue: typeof makeIssue;
-type external_d_ParseParams = ParseParams;
-type external_d_ParsePathComponent = ParsePathComponent;
-type external_d_ParsePath = ParsePath;
-declare const external_d_EMPTY_PATH: typeof EMPTY_PATH;
-type external_d_ParseContext = ParseContext;
-type external_d_ParseInput = ParseInput;
-declare const external_d_addIssueToContext: typeof addIssueToContext;
-type external_d_ObjectPair = ObjectPair;
-type external_d_ParseStatus = ParseStatus;
-declare const external_d_ParseStatus: typeof ParseStatus;
-type external_d_ParseResult = ParseResult;
-declare const external_d_INVALID: typeof INVALID;
-declare const external_d_DIRTY: typeof DIRTY;
-declare const external_d_OK: typeof OK;
-type external_d_SyncParseReturnType<T = any> = SyncParseReturnType<T>;
-type external_d_AsyncParseReturnType<T> = AsyncParseReturnType<T>;
-type external_d_ParseReturnType<T> = ParseReturnType<T>;
-declare const external_d_isAborted: typeof isAborted;
-declare const external_d_isDirty: typeof isDirty;
-declare const external_d_isValid: typeof isValid;
-declare const external_d_isAsync: typeof isAsync;
-declare const external_d_oboolean: typeof oboolean;
-declare const external_d_onumber: typeof onumber;
-declare const external_d_ostring: typeof ostring;
-type external_d_RefinementCtx = RefinementCtx;
-type external_d_ZodRawShape = ZodRawShape;
-type external_d_ZodTypeAny = ZodTypeAny;
-type external_d_TypeOf<T extends ZodType<any, any, any>> = TypeOf<T>;
-type external_d_input<T extends ZodType<any, any, any>> = input<T>;
-type external_d_output<T extends ZodType<any, any, any>> = output<T>;
-type external_d_CustomErrorParams = CustomErrorParams;
-type external_d_ZodTypeDef = ZodTypeDef;
-type external_d_SafeParseSuccess<Output> = SafeParseSuccess<Output>;
-type external_d_SafeParseError<Input> = SafeParseError<Input>;
-type external_d_SafeParseReturnType<Input, Output> = SafeParseReturnType<Input, Output>;
-type external_d_ZodType<Output, Def extends ZodTypeDef = ZodTypeDef, Input = Output> = ZodType<Output, Def, Input>;
-declare const external_d_ZodType: typeof ZodType;
-type external_d_ZodStringDef = ZodStringDef;
-type external_d_ZodString = ZodString;
-declare const external_d_ZodString: typeof ZodString;
-type external_d_ZodNumberDef = ZodNumberDef;
-type external_d_ZodNumber = ZodNumber;
-declare const external_d_ZodNumber: typeof ZodNumber;
-type external_d_ZodBigIntDef = ZodBigIntDef;
-type external_d_ZodBigInt = ZodBigInt;
-declare const external_d_ZodBigInt: typeof ZodBigInt;
-type external_d_ZodBooleanDef = ZodBooleanDef;
-type external_d_ZodBoolean = ZodBoolean;
-declare const external_d_ZodBoolean: typeof ZodBoolean;
-type external_d_ZodDateDef = ZodDateDef;
-type external_d_ZodDate = ZodDate;
-declare const external_d_ZodDate: typeof ZodDate;
-type external_d_ZodUndefinedDef = ZodUndefinedDef;
-type external_d_ZodUndefined = ZodUndefined;
-declare const external_d_ZodUndefined: typeof ZodUndefined;
-type external_d_ZodNullDef = ZodNullDef;
-type external_d_ZodNull = ZodNull;
-declare const external_d_ZodNull: typeof ZodNull;
-type external_d_ZodAnyDef = ZodAnyDef;
-type external_d_ZodAny = ZodAny;
-declare const external_d_ZodAny: typeof ZodAny;
-type external_d_ZodUnknownDef = ZodUnknownDef;
-type external_d_ZodUnknown = ZodUnknown;
-declare const external_d_ZodUnknown: typeof ZodUnknown;
-type external_d_ZodNeverDef = ZodNeverDef;
-type external_d_ZodNever = ZodNever;
-declare const external_d_ZodNever: typeof ZodNever;
-type external_d_ZodVoidDef = ZodVoidDef;
-type external_d_ZodVoid = ZodVoid;
-declare const external_d_ZodVoid: typeof ZodVoid;
-type external_d_ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> = ZodArrayDef<T>;
-type external_d_ArrayCardinality = ArrayCardinality;
-type external_d_ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = ZodArray<T, Cardinality>;
-declare const external_d_ZodArray: typeof ZodArray;
-type external_d_ZodNonEmptyArray<T extends ZodTypeAny> = ZodNonEmptyArray<T>;
-declare const external_d_objectUtil: typeof objectUtil;
-type external_d_extendShape<A, B> = extendShape<A, B>;
-type external_d_Primitive = Primitive;
-type external_d_Scalars = Scalars;
-type external_d_ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> = ZodObjectDef<T, UnknownKeys, Catchall>;
-type external_d_baseObjectOutputType<Shape extends ZodRawShape> = baseObjectOutputType<Shape>;
-type external_d_objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny> = objectOutputType<Shape, Catchall>;
-type external_d_baseObjectInputType<Shape extends ZodRawShape> = baseObjectInputType<Shape>;
-type external_d_objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny> = objectInputType<Shape, Catchall>;
-type external_d_SomeZodObject = SomeZodObject;
-type external_d_ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = "strip", Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall>, Input = objectInputType<T, Catchall>> = ZodObject<T, UnknownKeys, Catchall, Output, Input>;
-declare const external_d_ZodObject: typeof ZodObject;
-type external_d_AnyZodObject = AnyZodObject;
-type external_d_ZodUnionDef<T extends ZodUnionOptions = [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]> = ZodUnionDef<T>;
-type external_d_ZodUnion<T extends ZodUnionOptions> = ZodUnion<T>;
-declare const external_d_ZodUnion: typeof ZodUnion;
-type external_d_ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> = ZodIntersectionDef<T, U>;
-type external_d_ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> = ZodIntersection<T, U>;
-declare const external_d_ZodIntersection: typeof ZodIntersection;
-type external_d_ZodTupleItems = ZodTupleItems;
-type external_d_AssertArray<T extends any> = AssertArray<T>;
-type external_d_OutputTypeOfTuple<T extends ZodTupleItems | []> = OutputTypeOfTuple<T>;
-type external_d_OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = OutputTypeOfTupleWithRest<T, Rest>;
-type external_d_InputTypeOfTuple<T extends ZodTupleItems | []> = InputTypeOfTuple<T>;
-type external_d_InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = InputTypeOfTupleWithRest<T, Rest>;
-type external_d_ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> = ZodTupleDef<T, Rest>;
-type external_d_ZodTuple<T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null> = ZodTuple<T, Rest>;
-declare const external_d_ZodTuple: typeof ZodTuple;
-type external_d_ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> = ZodRecordDef<Key, Value>;
-type external_d_ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> = ZodRecord<Key, Value>;
-declare const external_d_ZodRecord: typeof ZodRecord;
-type external_d_ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> = ZodMapDef<Key, Value>;
-type external_d_ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> = ZodMap<Key, Value>;
-declare const external_d_ZodMap: typeof ZodMap;
-type external_d_ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> = ZodSetDef<Value>;
-type external_d_ZodSet<Value extends ZodTypeAny = ZodTypeAny> = ZodSet<Value>;
-declare const external_d_ZodSet: typeof ZodSet;
-type external_d_ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> = ZodFunctionDef<Args, Returns>;
-type external_d_OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = OuterTypeOfFunction<Args, Returns>;
-type external_d_InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = InnerTypeOfFunction<Args, Returns>;
-type external_d_ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = ZodFunction<Args, Returns>;
-declare const external_d_ZodFunction: typeof ZodFunction;
-type external_d_ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> = ZodLazyDef<T>;
-type external_d_ZodLazy<T extends ZodTypeAny> = ZodLazy<T>;
-declare const external_d_ZodLazy: typeof ZodLazy;
-type external_d_ZodLiteralDef<T extends any = any> = ZodLiteralDef<T>;
-type external_d_ZodLiteral<T extends any> = ZodLiteral<T>;
-declare const external_d_ZodLiteral: typeof ZodLiteral;
-type external_d_ArrayKeys = ArrayKeys;
-type external_d_Indices<T> = Indices<T>;
-type external_d_ZodEnumDef<T extends EnumValues = EnumValues> = ZodEnumDef<T>;
-type external_d_ZodEnum<T extends [string, ...string[]]> = ZodEnum<T>;
-declare const external_d_ZodEnum: typeof ZodEnum;
-type external_d_ZodNativeEnumDef<T extends EnumLike = EnumLike> = ZodNativeEnumDef<T>;
-type external_d_ZodNativeEnum<T extends EnumLike> = ZodNativeEnum<T>;
-declare const external_d_ZodNativeEnum: typeof ZodNativeEnum;
-type external_d_ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> = ZodPromiseDef<T>;
-type external_d_ZodPromise<T extends ZodTypeAny> = ZodPromise<T>;
-declare const external_d_ZodPromise: typeof ZodPromise;
-type external_d_Refinement<T> = Refinement<T>;
-type external_d_SuperRefinement<T> = SuperRefinement<T>;
-type external_d_RefinementEffect<T> = RefinementEffect<T>;
-type external_d_TransformEffect<T> = TransformEffect<T>;
-type external_d_PreprocessEffect<T> = PreprocessEffect<T>;
-type external_d_Effect<T> = Effect<T>;
-type external_d_ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> = ZodEffectsDef<T>;
-type external_d_ZodEffects<T extends ZodTypeAny, Output = T["_output"], Input = T["_input"]> = ZodEffects<T, Output, Input>;
-declare const external_d_ZodEffects: typeof ZodEffects;
-type external_d_ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> = ZodOptionalDef<T>;
-type external_d_ZodOptionalType<T extends ZodTypeAny> = ZodOptionalType<T>;
-type external_d_ZodOptional<T extends ZodTypeAny> = ZodOptional<T>;
-declare const external_d_ZodOptional: typeof ZodOptional;
-type external_d_ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> = ZodNullableDef<T>;
-type external_d_ZodNullableType<T extends ZodTypeAny> = ZodNullableType<T>;
-type external_d_ZodNullable<T extends ZodTypeAny> = ZodNullable<T>;
-declare const external_d_ZodNullable: typeof ZodNullable;
-type external_d_ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> = ZodDefaultDef<T>;
-type external_d_ZodDefault<T extends ZodTypeAny> = ZodDefault<T>;
-declare const external_d_ZodDefault: typeof ZodDefault;
-declare const external_d_custom: typeof custom;
-declare const external_d_late: typeof late;
-type external_d_ZodFirstPartyTypeKind = ZodFirstPartyTypeKind;
-declare const external_d_ZodFirstPartyTypeKind: typeof ZodFirstPartyTypeKind;
-type external_d_ZodFirstPartySchemaTypes = ZodFirstPartySchemaTypes;
-type external_d_ZodIssueCode = ZodIssueCode;
-type external_d_ZodIssueBase = ZodIssueBase;
-type external_d_ZodInvalidTypeIssue = ZodInvalidTypeIssue;
-type external_d_ZodUnrecognizedKeysIssue = ZodUnrecognizedKeysIssue;
-type external_d_ZodInvalidUnionIssue = ZodInvalidUnionIssue;
-type external_d_ZodInvalidEnumValueIssue = ZodInvalidEnumValueIssue;
-type external_d_ZodInvalidArgumentsIssue = ZodInvalidArgumentsIssue;
-type external_d_ZodInvalidReturnTypeIssue = ZodInvalidReturnTypeIssue;
-type external_d_ZodInvalidDateIssue = ZodInvalidDateIssue;
-type external_d_StringValidation = StringValidation;
-type external_d_ZodInvalidStringIssue = ZodInvalidStringIssue;
-type external_d_ZodTooSmallIssue = ZodTooSmallIssue;
-type external_d_ZodTooBigIssue = ZodTooBigIssue;
-type external_d_ZodInvalidIntersectionTypesIssue = ZodInvalidIntersectionTypesIssue;
-type external_d_ZodNotMultipleOfIssue = ZodNotMultipleOfIssue;
-type external_d_ZodCustomIssue = ZodCustomIssue;
-type external_d_DenormalizedError = DenormalizedError;
-type external_d_ZodIssueOptionalMessage = ZodIssueOptionalMessage;
-type external_d_ZodIssue = ZodIssue;
-declare const external_d_quotelessJson: typeof quotelessJson;
-type external_d_ZodFormattedError<T> = ZodFormattedError<T>;
-type external_d_ZodError<T = any> = ZodError<T>;
-declare const external_d_ZodError: typeof ZodError;
-type external_d_IssueData = IssueData;
-type external_d_MakeErrorData = MakeErrorData;
-type external_d_ZodErrorMap = ZodErrorMap;
-declare const external_d_defaultErrorMap: typeof defaultErrorMap;
-declare const external_d_overrideErrorMap: typeof overrideErrorMap;
-declare const external_d_setErrorMap: typeof setErrorMap;
-declare namespace external_d {
+type mod_ZodParsedType = ZodParsedType;
+declare const mod_getParsedType: typeof getParsedType;
+declare const mod_makeIssue: typeof makeIssue;
+type mod_ParseParams = ParseParams;
+type mod_ParsePathComponent = ParsePathComponent;
+type mod_ParsePath = ParsePath;
+declare const mod_EMPTY_PATH: typeof EMPTY_PATH;
+type mod_ParseContext = ParseContext;
+type mod_ParseInput = ParseInput;
+declare const mod_addIssueToContext: typeof addIssueToContext;
+type mod_ObjectPair = ObjectPair;
+type mod_ParseStatus = ParseStatus;
+declare const mod_ParseStatus: typeof ParseStatus;
+type mod_ParseResult = ParseResult;
+declare const mod_INVALID: typeof INVALID;
+declare const mod_DIRTY: typeof DIRTY;
+declare const mod_OK: typeof OK;
+type mod_SyncParseReturnType<T = any> = SyncParseReturnType<T>;
+type mod_AsyncParseReturnType<T> = AsyncParseReturnType<T>;
+type mod_ParseReturnType<T> = ParseReturnType<T>;
+declare const mod_isAborted: typeof isAborted;
+declare const mod_isDirty: typeof isDirty;
+declare const mod_isValid: typeof isValid;
+declare const mod_isAsync: typeof isAsync;
+type mod_Primitive = Primitive;
+type mod_Scalars = Scalars;
+declare const mod_oboolean: typeof oboolean;
+declare const mod_onumber: typeof onumber;
+declare const mod_ostring: typeof ostring;
+type mod_RefinementCtx = RefinementCtx;
+type mod_ZodRawShape = ZodRawShape;
+type mod_ZodTypeAny = ZodTypeAny;
+type mod_TypeOf<T extends ZodType<any, any, any>> = TypeOf<T>;
+type mod_input<T extends ZodType<any, any, any>> = input<T>;
+type mod_output<T extends ZodType<any, any, any>> = output<T>;
+type mod_TypeOfFlattenedError<T extends ZodType<any, any, any>, U = string> = TypeOfFlattenedError<T, U>;
+type mod_TypeOfFormErrors<T extends ZodType<any, any, any>> = TypeOfFormErrors<T>;
+type mod_CustomErrorParams = CustomErrorParams;
+type mod_ZodTypeDef = ZodTypeDef;
+type mod_SafeParseSuccess<Output> = SafeParseSuccess<Output>;
+type mod_SafeParseError<Input> = SafeParseError<Input>;
+type mod_SafeParseReturnType<Input, Output> = SafeParseReturnType<Input, Output>;
+type mod_ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> = ZodType<Output, Def, Input>;
+declare const mod_ZodType: typeof ZodType;
+type mod_ZodStringDef = ZodStringDef;
+type mod_ZodString = ZodString;
+declare const mod_ZodString: typeof ZodString;
+type mod_ZodNumberDef = ZodNumberDef;
+type mod_ZodNumber = ZodNumber;
+declare const mod_ZodNumber: typeof ZodNumber;
+type mod_ZodBigIntDef = ZodBigIntDef;
+type mod_ZodBigInt = ZodBigInt;
+declare const mod_ZodBigInt: typeof ZodBigInt;
+type mod_ZodBooleanDef = ZodBooleanDef;
+type mod_ZodBoolean = ZodBoolean;
+declare const mod_ZodBoolean: typeof ZodBoolean;
+type mod_ZodDateDef = ZodDateDef;
+type mod_ZodDate = ZodDate;
+declare const mod_ZodDate: typeof ZodDate;
+type mod_ZodUndefinedDef = ZodUndefinedDef;
+type mod_ZodUndefined = ZodUndefined;
+declare const mod_ZodUndefined: typeof ZodUndefined;
+type mod_ZodNullDef = ZodNullDef;
+type mod_ZodNull = ZodNull;
+declare const mod_ZodNull: typeof ZodNull;
+type mod_ZodAnyDef = ZodAnyDef;
+type mod_ZodAny = ZodAny;
+declare const mod_ZodAny: typeof ZodAny;
+type mod_ZodUnknownDef = ZodUnknownDef;
+type mod_ZodUnknown = ZodUnknown;
+declare const mod_ZodUnknown: typeof ZodUnknown;
+type mod_ZodNeverDef = ZodNeverDef;
+type mod_ZodNever = ZodNever;
+declare const mod_ZodNever: typeof ZodNever;
+type mod_ZodVoidDef = ZodVoidDef;
+type mod_ZodVoid = ZodVoid;
+declare const mod_ZodVoid: typeof ZodVoid;
+type mod_ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> = ZodArrayDef<T>;
+type mod_ArrayCardinality = ArrayCardinality;
+type mod_ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = ZodArray<T, Cardinality>;
+declare const mod_ZodArray: typeof ZodArray;
+type mod_ZodNonEmptyArray<T extends ZodTypeAny> = ZodNonEmptyArray<T>;
+declare const mod_objectUtil: typeof objectUtil;
+type mod_extendShape<A, B> = extendShape<A, B>;
+type mod_ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> = ZodObjectDef<T, UnknownKeys, Catchall>;
+type mod_baseObjectOutputType<Shape extends ZodRawShape> = baseObjectOutputType<Shape>;
+type mod_objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny> = objectOutputType<Shape, Catchall>;
+type mod_baseObjectInputType<Shape extends ZodRawShape> = baseObjectInputType<Shape>;
+type mod_objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny> = objectInputType<Shape, Catchall>;
+type mod_SomeZodObject = SomeZodObject;
+type mod_ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = "strip", Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall>, Input = objectInputType<T, Catchall>> = ZodObject<T, UnknownKeys, Catchall, Output, Input>;
+declare const mod_ZodObject: typeof ZodObject;
+type mod_AnyZodObject = AnyZodObject;
+type mod_ZodUnionDef<T extends ZodUnionOptions = Readonly<[
+    ZodTypeAny,
+    ZodTypeAny,
+    ...ZodTypeAny[]
+]>> = ZodUnionDef<T>;
+type mod_ZodUnion<T extends ZodUnionOptions> = ZodUnion<T>;
+declare const mod_ZodUnion: typeof ZodUnion;
+type mod_ZodDiscriminatedUnionOption<Discriminator extends string, DiscriminatorValue extends Primitive> = ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>;
+type mod_ZodDiscriminatedUnionDef<Discriminator extends string, DiscriminatorValue extends Primitive, Option extends ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>> = ZodDiscriminatedUnionDef<Discriminator, DiscriminatorValue, Option>;
+type mod_ZodDiscriminatedUnion<Discriminator extends string, DiscriminatorValue extends Primitive, Option extends ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>> = ZodDiscriminatedUnion<Discriminator, DiscriminatorValue, Option>;
+declare const mod_ZodDiscriminatedUnion: typeof ZodDiscriminatedUnion;
+type mod_ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> = ZodIntersectionDef<T, U>;
+type mod_ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> = ZodIntersection<T, U>;
+declare const mod_ZodIntersection: typeof ZodIntersection;
+type mod_ZodTupleItems = ZodTupleItems;
+type mod_AssertArray<T> = AssertArray<T>;
+type mod_OutputTypeOfTuple<T extends ZodTupleItems | []> = OutputTypeOfTuple<T>;
+type mod_OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = OutputTypeOfTupleWithRest<T, Rest>;
+type mod_InputTypeOfTuple<T extends ZodTupleItems | []> = InputTypeOfTuple<T>;
+type mod_InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = InputTypeOfTupleWithRest<T, Rest>;
+type mod_ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> = ZodTupleDef<T, Rest>;
+type mod_ZodTuple<T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null> = ZodTuple<T, Rest>;
+declare const mod_ZodTuple: typeof ZodTuple;
+type mod_ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> = ZodRecordDef<Key, Value>;
+type mod_ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> = ZodRecord<Key, Value>;
+declare const mod_ZodRecord: typeof ZodRecord;
+type mod_ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> = ZodMapDef<Key, Value>;
+type mod_ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> = ZodMap<Key, Value>;
+declare const mod_ZodMap: typeof ZodMap;
+type mod_ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> = ZodSetDef<Value>;
+type mod_ZodSet<Value extends ZodTypeAny = ZodTypeAny> = ZodSet<Value>;
+declare const mod_ZodSet: typeof ZodSet;
+type mod_ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> = ZodFunctionDef<Args, Returns>;
+type mod_OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = OuterTypeOfFunction<Args, Returns>;
+type mod_InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = InnerTypeOfFunction<Args, Returns>;
+type mod_ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = ZodFunction<Args, Returns>;
+declare const mod_ZodFunction: typeof ZodFunction;
+type mod_ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> = ZodLazyDef<T>;
+type mod_ZodLazy<T extends ZodTypeAny> = ZodLazy<T>;
+declare const mod_ZodLazy: typeof ZodLazy;
+type mod_ZodLiteralDef<T = any> = ZodLiteralDef<T>;
+type mod_ZodLiteral<T> = ZodLiteral<T>;
+declare const mod_ZodLiteral: typeof ZodLiteral;
+type mod_ArrayKeys = ArrayKeys;
+type mod_Indices<T> = Indices<T>;
+type mod_ZodEnumDef<T extends EnumValues = EnumValues> = ZodEnumDef<T>;
+type mod_ZodEnum<T extends [string, ...string[]]> = ZodEnum<T>;
+declare const mod_ZodEnum: typeof ZodEnum;
+type mod_ZodNativeEnumDef<T extends EnumLike = EnumLike> = ZodNativeEnumDef<T>;
+type mod_ZodNativeEnum<T extends EnumLike> = ZodNativeEnum<T>;
+declare const mod_ZodNativeEnum: typeof ZodNativeEnum;
+type mod_ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> = ZodPromiseDef<T>;
+type mod_ZodPromise<T extends ZodTypeAny> = ZodPromise<T>;
+declare const mod_ZodPromise: typeof ZodPromise;
+type mod_Refinement<T> = Refinement<T>;
+type mod_SuperRefinement<T> = SuperRefinement<T>;
+type mod_RefinementEffect<T> = RefinementEffect<T>;
+type mod_TransformEffect<T> = TransformEffect<T>;
+type mod_PreprocessEffect<T> = PreprocessEffect<T>;
+type mod_Effect<T> = Effect<T>;
+type mod_ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> = ZodEffectsDef<T>;
+type mod_ZodEffects<T extends ZodTypeAny, Output = T["_output"], Input = T["_input"]> = ZodEffects<T, Output, Input>;
+declare const mod_ZodEffects: typeof ZodEffects;
+type mod_ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> = ZodOptionalDef<T>;
+type mod_ZodOptionalType<T extends ZodTypeAny> = ZodOptionalType<T>;
+type mod_ZodOptional<T extends ZodTypeAny> = ZodOptional<T>;
+declare const mod_ZodOptional: typeof ZodOptional;
+type mod_ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> = ZodNullableDef<T>;
+type mod_ZodNullableType<T extends ZodTypeAny> = ZodNullableType<T>;
+type mod_ZodNullable<T extends ZodTypeAny> = ZodNullable<T>;
+declare const mod_ZodNullable: typeof ZodNullable;
+type mod_ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> = ZodDefaultDef<T>;
+type mod_ZodDefault<T extends ZodTypeAny> = ZodDefault<T>;
+declare const mod_ZodDefault: typeof ZodDefault;
+type mod_ZodNaNDef = ZodNaNDef;
+type mod_ZodNaN = ZodNaN;
+declare const mod_ZodNaN: typeof ZodNaN;
+declare const mod_custom: typeof custom;
+declare const mod_late: typeof late;
+type mod_ZodFirstPartyTypeKind = ZodFirstPartyTypeKind;
+declare const mod_ZodFirstPartyTypeKind: typeof ZodFirstPartyTypeKind;
+type mod_ZodFirstPartySchemaTypes = ZodFirstPartySchemaTypes;
+type mod_ZodIssueCode = ZodIssueCode;
+type mod_ZodIssueBase = ZodIssueBase;
+type mod_ZodInvalidTypeIssue = ZodInvalidTypeIssue;
+type mod_ZodUnrecognizedKeysIssue = ZodUnrecognizedKeysIssue;
+type mod_ZodInvalidUnionIssue = ZodInvalidUnionIssue;
+type mod_ZodInvalidUnionDiscriminatorIssue = ZodInvalidUnionDiscriminatorIssue;
+type mod_ZodInvalidEnumValueIssue = ZodInvalidEnumValueIssue;
+type mod_ZodInvalidArgumentsIssue = ZodInvalidArgumentsIssue;
+type mod_ZodInvalidReturnTypeIssue = ZodInvalidReturnTypeIssue;
+type mod_ZodInvalidDateIssue = ZodInvalidDateIssue;
+type mod_StringValidation = StringValidation;
+type mod_ZodInvalidStringIssue = ZodInvalidStringIssue;
+type mod_ZodTooSmallIssue = ZodTooSmallIssue;
+type mod_ZodTooBigIssue = ZodTooBigIssue;
+type mod_ZodInvalidIntersectionTypesIssue = ZodInvalidIntersectionTypesIssue;
+type mod_ZodNotMultipleOfIssue = ZodNotMultipleOfIssue;
+type mod_ZodCustomIssue = ZodCustomIssue;
+type mod_DenormalizedError = DenormalizedError;
+type mod_ZodIssueOptionalMessage = ZodIssueOptionalMessage;
+type mod_ZodIssue = ZodIssue;
+declare const mod_quotelessJson: typeof quotelessJson;
+type mod_ZodFormattedError<T> = ZodFormattedError<T>;
+type mod_ZodError<T = any> = ZodError<T>;
+declare const mod_ZodError: typeof ZodError;
+type mod_IssueData = IssueData;
+type mod_MakeErrorData = MakeErrorData;
+type mod_ZodErrorMap = ZodErrorMap;
+declare const mod_defaultErrorMap: typeof defaultErrorMap;
+declare const mod_overrideErrorMap: typeof overrideErrorMap;
+declare const mod_setErrorMap: typeof setErrorMap;
+declare namespace mod {
   export {
-    external_d_ZodParsedType as ZodParsedType,
-    external_d_getParsedType as getParsedType,
-    external_d_makeIssue as makeIssue,
-    external_d_ParseParams as ParseParams,
-    external_d_ParsePathComponent as ParsePathComponent,
-    external_d_ParsePath as ParsePath,
-    external_d_EMPTY_PATH as EMPTY_PATH,
-    external_d_ParseContext as ParseContext,
-    external_d_ParseInput as ParseInput,
-    external_d_addIssueToContext as addIssueToContext,
-    external_d_ObjectPair as ObjectPair,
-    external_d_ParseStatus as ParseStatus,
-    external_d_ParseResult as ParseResult,
-    external_d_INVALID as INVALID,
-    external_d_DIRTY as DIRTY,
-    external_d_OK as OK,
-    external_d_SyncParseReturnType as SyncParseReturnType,
-    external_d_AsyncParseReturnType as AsyncParseReturnType,
-    external_d_ParseReturnType as ParseReturnType,
-    external_d_isAborted as isAborted,
-    external_d_isDirty as isDirty,
-    external_d_isValid as isValid,
-    external_d_isAsync as isAsync,
+    mod_ZodParsedType as ZodParsedType,
+    mod_getParsedType as getParsedType,
+    mod_makeIssue as makeIssue,
+    mod_ParseParams as ParseParams,
+    mod_ParsePathComponent as ParsePathComponent,
+    mod_ParsePath as ParsePath,
+    mod_EMPTY_PATH as EMPTY_PATH,
+    mod_ParseContext as ParseContext,
+    mod_ParseInput as ParseInput,
+    mod_addIssueToContext as addIssueToContext,
+    mod_ObjectPair as ObjectPair,
+    mod_ParseStatus as ParseStatus,
+    mod_ParseResult as ParseResult,
+    mod_INVALID as INVALID,
+    mod_DIRTY as DIRTY,
+    mod_OK as OK,
+    mod_SyncParseReturnType as SyncParseReturnType,
+    mod_AsyncParseReturnType as AsyncParseReturnType,
+    mod_ParseReturnType as ParseReturnType,
+    mod_isAborted as isAborted,
+    mod_isDirty as isDirty,
+    mod_isValid as isValid,
+    mod_isAsync as isAsync,
+    mod_Primitive as Primitive,
+    mod_Scalars as Scalars,
     TypeOf as infer,
+    TypeOfFlattenedError as inferFlattenedErrors,
+    TypeOfFormErrors as inferFormErrors,
     ZodEffects as ZodTransformer,
     ZodType as Schema,
     ZodType as ZodSchema,
@@ -3510,6 +5213,7 @@ declare namespace external_d {
     bigIntType as bigint,
     booleanType as boolean,
     dateType as date,
+    discriminatedUnionType as discriminatedUnion,
     effectsType as effect,
     enumType as enum,
     functionType as function,
@@ -3518,16 +5222,17 @@ declare namespace external_d {
     lazyType as lazy,
     literalType as literal,
     mapType as map,
+    nanType as nan,
     nativeEnumType as nativeEnum,
     neverType as never,
     nullType as null,
     nullableType as nullable,
     numberType as number,
     objectType as object,
-    external_d_oboolean as oboolean,
-    external_d_onumber as onumber,
+    mod_oboolean as oboolean,
+    mod_onumber as onumber,
     optionalType as optional,
-    external_d_ostring as ostring,
+    mod_ostring as ostring,
     preprocessType as preprocess,
     promiseType as promise,
     recordType as record,
@@ -3540,144 +5245,150 @@ declare namespace external_d {
     unionType as union,
     unknownType as unknown,
     voidType as void,
-    external_d_RefinementCtx as RefinementCtx,
-    external_d_ZodRawShape as ZodRawShape,
-    external_d_ZodTypeAny as ZodTypeAny,
-    external_d_TypeOf as TypeOf,
-    external_d_input as input,
-    external_d_output as output,
-    external_d_CustomErrorParams as CustomErrorParams,
-    external_d_ZodTypeDef as ZodTypeDef,
-    external_d_SafeParseSuccess as SafeParseSuccess,
-    external_d_SafeParseError as SafeParseError,
-    external_d_SafeParseReturnType as SafeParseReturnType,
-    external_d_ZodType as ZodType,
-    external_d_ZodStringDef as ZodStringDef,
-    external_d_ZodString as ZodString,
-    external_d_ZodNumberDef as ZodNumberDef,
-    external_d_ZodNumber as ZodNumber,
-    external_d_ZodBigIntDef as ZodBigIntDef,
-    external_d_ZodBigInt as ZodBigInt,
-    external_d_ZodBooleanDef as ZodBooleanDef,
-    external_d_ZodBoolean as ZodBoolean,
-    external_d_ZodDateDef as ZodDateDef,
-    external_d_ZodDate as ZodDate,
-    external_d_ZodUndefinedDef as ZodUndefinedDef,
-    external_d_ZodUndefined as ZodUndefined,
-    external_d_ZodNullDef as ZodNullDef,
-    external_d_ZodNull as ZodNull,
-    external_d_ZodAnyDef as ZodAnyDef,
-    external_d_ZodAny as ZodAny,
-    external_d_ZodUnknownDef as ZodUnknownDef,
-    external_d_ZodUnknown as ZodUnknown,
-    external_d_ZodNeverDef as ZodNeverDef,
-    external_d_ZodNever as ZodNever,
-    external_d_ZodVoidDef as ZodVoidDef,
-    external_d_ZodVoid as ZodVoid,
-    external_d_ZodArrayDef as ZodArrayDef,
-    external_d_ArrayCardinality as ArrayCardinality,
-    external_d_ZodArray as ZodArray,
-    external_d_ZodNonEmptyArray as ZodNonEmptyArray,
-    external_d_objectUtil as objectUtil,
-    external_d_extendShape as extendShape,
-    external_d_Primitive as Primitive,
-    external_d_Scalars as Scalars,
-    external_d_ZodObjectDef as ZodObjectDef,
-    external_d_baseObjectOutputType as baseObjectOutputType,
-    external_d_objectOutputType as objectOutputType,
-    external_d_baseObjectInputType as baseObjectInputType,
-    external_d_objectInputType as objectInputType,
-    external_d_SomeZodObject as SomeZodObject,
-    external_d_ZodObject as ZodObject,
-    external_d_AnyZodObject as AnyZodObject,
-    external_d_ZodUnionDef as ZodUnionDef,
-    external_d_ZodUnion as ZodUnion,
-    external_d_ZodIntersectionDef as ZodIntersectionDef,
-    external_d_ZodIntersection as ZodIntersection,
-    external_d_ZodTupleItems as ZodTupleItems,
-    external_d_AssertArray as AssertArray,
-    external_d_OutputTypeOfTuple as OutputTypeOfTuple,
-    external_d_OutputTypeOfTupleWithRest as OutputTypeOfTupleWithRest,
-    external_d_InputTypeOfTuple as InputTypeOfTuple,
-    external_d_InputTypeOfTupleWithRest as InputTypeOfTupleWithRest,
-    external_d_ZodTupleDef as ZodTupleDef,
-    external_d_ZodTuple as ZodTuple,
-    external_d_ZodRecordDef as ZodRecordDef,
-    external_d_ZodRecord as ZodRecord,
-    external_d_ZodMapDef as ZodMapDef,
-    external_d_ZodMap as ZodMap,
-    external_d_ZodSetDef as ZodSetDef,
-    external_d_ZodSet as ZodSet,
-    external_d_ZodFunctionDef as ZodFunctionDef,
-    external_d_OuterTypeOfFunction as OuterTypeOfFunction,
-    external_d_InnerTypeOfFunction as InnerTypeOfFunction,
-    external_d_ZodFunction as ZodFunction,
-    external_d_ZodLazyDef as ZodLazyDef,
-    external_d_ZodLazy as ZodLazy,
-    external_d_ZodLiteralDef as ZodLiteralDef,
-    external_d_ZodLiteral as ZodLiteral,
-    external_d_ArrayKeys as ArrayKeys,
-    external_d_Indices as Indices,
-    external_d_ZodEnumDef as ZodEnumDef,
-    external_d_ZodEnum as ZodEnum,
-    external_d_ZodNativeEnumDef as ZodNativeEnumDef,
-    external_d_ZodNativeEnum as ZodNativeEnum,
-    external_d_ZodPromiseDef as ZodPromiseDef,
-    external_d_ZodPromise as ZodPromise,
-    external_d_Refinement as Refinement,
-    external_d_SuperRefinement as SuperRefinement,
-    external_d_RefinementEffect as RefinementEffect,
-    external_d_TransformEffect as TransformEffect,
-    external_d_PreprocessEffect as PreprocessEffect,
-    external_d_Effect as Effect,
-    external_d_ZodEffectsDef as ZodEffectsDef,
-    external_d_ZodEffects as ZodEffects,
-    external_d_ZodOptionalDef as ZodOptionalDef,
-    external_d_ZodOptionalType as ZodOptionalType,
-    external_d_ZodOptional as ZodOptional,
-    external_d_ZodNullableDef as ZodNullableDef,
-    external_d_ZodNullableType as ZodNullableType,
-    external_d_ZodNullable as ZodNullable,
-    external_d_ZodDefaultDef as ZodDefaultDef,
-    external_d_ZodDefault as ZodDefault,
-    external_d_custom as custom,
-    external_d_late as late,
-    external_d_ZodFirstPartyTypeKind as ZodFirstPartyTypeKind,
-    external_d_ZodFirstPartySchemaTypes as ZodFirstPartySchemaTypes,
-    external_d_ZodIssueCode as ZodIssueCode,
-    external_d_ZodIssueBase as ZodIssueBase,
-    external_d_ZodInvalidTypeIssue as ZodInvalidTypeIssue,
-    external_d_ZodUnrecognizedKeysIssue as ZodUnrecognizedKeysIssue,
-    external_d_ZodInvalidUnionIssue as ZodInvalidUnionIssue,
-    external_d_ZodInvalidEnumValueIssue as ZodInvalidEnumValueIssue,
-    external_d_ZodInvalidArgumentsIssue as ZodInvalidArgumentsIssue,
-    external_d_ZodInvalidReturnTypeIssue as ZodInvalidReturnTypeIssue,
-    external_d_ZodInvalidDateIssue as ZodInvalidDateIssue,
-    external_d_StringValidation as StringValidation,
-    external_d_ZodInvalidStringIssue as ZodInvalidStringIssue,
-    external_d_ZodTooSmallIssue as ZodTooSmallIssue,
-    external_d_ZodTooBigIssue as ZodTooBigIssue,
-    external_d_ZodInvalidIntersectionTypesIssue as ZodInvalidIntersectionTypesIssue,
-    external_d_ZodNotMultipleOfIssue as ZodNotMultipleOfIssue,
-    external_d_ZodCustomIssue as ZodCustomIssue,
-    external_d_DenormalizedError as DenormalizedError,
-    external_d_ZodIssueOptionalMessage as ZodIssueOptionalMessage,
-    external_d_ZodIssue as ZodIssue,
-    external_d_quotelessJson as quotelessJson,
-    external_d_ZodFormattedError as ZodFormattedError,
-    external_d_ZodError as ZodError,
-    external_d_IssueData as IssueData,
-    external_d_MakeErrorData as MakeErrorData,
-    external_d_ZodErrorMap as ZodErrorMap,
-    external_d_defaultErrorMap as defaultErrorMap,
-    external_d_overrideErrorMap as overrideErrorMap,
-    external_d_setErrorMap as setErrorMap,
+    mod_RefinementCtx as RefinementCtx,
+    mod_ZodRawShape as ZodRawShape,
+    mod_ZodTypeAny as ZodTypeAny,
+    mod_TypeOf as TypeOf,
+    mod_input as input,
+    mod_output as output,
+    mod_TypeOfFlattenedError as TypeOfFlattenedError,
+    mod_TypeOfFormErrors as TypeOfFormErrors,
+    mod_CustomErrorParams as CustomErrorParams,
+    mod_ZodTypeDef as ZodTypeDef,
+    mod_SafeParseSuccess as SafeParseSuccess,
+    mod_SafeParseError as SafeParseError,
+    mod_SafeParseReturnType as SafeParseReturnType,
+    mod_ZodType as ZodType,
+    mod_ZodStringDef as ZodStringDef,
+    mod_ZodString as ZodString,
+    mod_ZodNumberDef as ZodNumberDef,
+    mod_ZodNumber as ZodNumber,
+    mod_ZodBigIntDef as ZodBigIntDef,
+    mod_ZodBigInt as ZodBigInt,
+    mod_ZodBooleanDef as ZodBooleanDef,
+    mod_ZodBoolean as ZodBoolean,
+    mod_ZodDateDef as ZodDateDef,
+    mod_ZodDate as ZodDate,
+    mod_ZodUndefinedDef as ZodUndefinedDef,
+    mod_ZodUndefined as ZodUndefined,
+    mod_ZodNullDef as ZodNullDef,
+    mod_ZodNull as ZodNull,
+    mod_ZodAnyDef as ZodAnyDef,
+    mod_ZodAny as ZodAny,
+    mod_ZodUnknownDef as ZodUnknownDef,
+    mod_ZodUnknown as ZodUnknown,
+    mod_ZodNeverDef as ZodNeverDef,
+    mod_ZodNever as ZodNever,
+    mod_ZodVoidDef as ZodVoidDef,
+    mod_ZodVoid as ZodVoid,
+    mod_ZodArrayDef as ZodArrayDef,
+    mod_ArrayCardinality as ArrayCardinality,
+    mod_ZodArray as ZodArray,
+    mod_ZodNonEmptyArray as ZodNonEmptyArray,
+    mod_objectUtil as objectUtil,
+    mod_extendShape as extendShape,
+    mod_ZodObjectDef as ZodObjectDef,
+    mod_baseObjectOutputType as baseObjectOutputType,
+    mod_objectOutputType as objectOutputType,
+    mod_baseObjectInputType as baseObjectInputType,
+    mod_objectInputType as objectInputType,
+    mod_SomeZodObject as SomeZodObject,
+    mod_ZodObject as ZodObject,
+    mod_AnyZodObject as AnyZodObject,
+    mod_ZodUnionDef as ZodUnionDef,
+    mod_ZodUnion as ZodUnion,
+    mod_ZodDiscriminatedUnionOption as ZodDiscriminatedUnionOption,
+    mod_ZodDiscriminatedUnionDef as ZodDiscriminatedUnionDef,
+    mod_ZodDiscriminatedUnion as ZodDiscriminatedUnion,
+    mod_ZodIntersectionDef as ZodIntersectionDef,
+    mod_ZodIntersection as ZodIntersection,
+    mod_ZodTupleItems as ZodTupleItems,
+    mod_AssertArray as AssertArray,
+    mod_OutputTypeOfTuple as OutputTypeOfTuple,
+    mod_OutputTypeOfTupleWithRest as OutputTypeOfTupleWithRest,
+    mod_InputTypeOfTuple as InputTypeOfTuple,
+    mod_InputTypeOfTupleWithRest as InputTypeOfTupleWithRest,
+    mod_ZodTupleDef as ZodTupleDef,
+    mod_ZodTuple as ZodTuple,
+    mod_ZodRecordDef as ZodRecordDef,
+    mod_ZodRecord as ZodRecord,
+    mod_ZodMapDef as ZodMapDef,
+    mod_ZodMap as ZodMap,
+    mod_ZodSetDef as ZodSetDef,
+    mod_ZodSet as ZodSet,
+    mod_ZodFunctionDef as ZodFunctionDef,
+    mod_OuterTypeOfFunction as OuterTypeOfFunction,
+    mod_InnerTypeOfFunction as InnerTypeOfFunction,
+    mod_ZodFunction as ZodFunction,
+    mod_ZodLazyDef as ZodLazyDef,
+    mod_ZodLazy as ZodLazy,
+    mod_ZodLiteralDef as ZodLiteralDef,
+    mod_ZodLiteral as ZodLiteral,
+    mod_ArrayKeys as ArrayKeys,
+    mod_Indices as Indices,
+    mod_ZodEnumDef as ZodEnumDef,
+    mod_ZodEnum as ZodEnum,
+    mod_ZodNativeEnumDef as ZodNativeEnumDef,
+    mod_ZodNativeEnum as ZodNativeEnum,
+    mod_ZodPromiseDef as ZodPromiseDef,
+    mod_ZodPromise as ZodPromise,
+    mod_Refinement as Refinement,
+    mod_SuperRefinement as SuperRefinement,
+    mod_RefinementEffect as RefinementEffect,
+    mod_TransformEffect as TransformEffect,
+    mod_PreprocessEffect as PreprocessEffect,
+    mod_Effect as Effect,
+    mod_ZodEffectsDef as ZodEffectsDef,
+    mod_ZodEffects as ZodEffects,
+    mod_ZodOptionalDef as ZodOptionalDef,
+    mod_ZodOptionalType as ZodOptionalType,
+    mod_ZodOptional as ZodOptional,
+    mod_ZodNullableDef as ZodNullableDef,
+    mod_ZodNullableType as ZodNullableType,
+    mod_ZodNullable as ZodNullable,
+    mod_ZodDefaultDef as ZodDefaultDef,
+    mod_ZodDefault as ZodDefault,
+    mod_ZodNaNDef as ZodNaNDef,
+    mod_ZodNaN as ZodNaN,
+    mod_custom as custom,
+    mod_late as late,
+    mod_ZodFirstPartyTypeKind as ZodFirstPartyTypeKind,
+    mod_ZodFirstPartySchemaTypes as ZodFirstPartySchemaTypes,
+    mod_ZodIssueCode as ZodIssueCode,
+    mod_ZodIssueBase as ZodIssueBase,
+    mod_ZodInvalidTypeIssue as ZodInvalidTypeIssue,
+    mod_ZodUnrecognizedKeysIssue as ZodUnrecognizedKeysIssue,
+    mod_ZodInvalidUnionIssue as ZodInvalidUnionIssue,
+    mod_ZodInvalidUnionDiscriminatorIssue as ZodInvalidUnionDiscriminatorIssue,
+    mod_ZodInvalidEnumValueIssue as ZodInvalidEnumValueIssue,
+    mod_ZodInvalidArgumentsIssue as ZodInvalidArgumentsIssue,
+    mod_ZodInvalidReturnTypeIssue as ZodInvalidReturnTypeIssue,
+    mod_ZodInvalidDateIssue as ZodInvalidDateIssue,
+    mod_StringValidation as StringValidation,
+    mod_ZodInvalidStringIssue as ZodInvalidStringIssue,
+    mod_ZodTooSmallIssue as ZodTooSmallIssue,
+    mod_ZodTooBigIssue as ZodTooBigIssue,
+    mod_ZodInvalidIntersectionTypesIssue as ZodInvalidIntersectionTypesIssue,
+    mod_ZodNotMultipleOfIssue as ZodNotMultipleOfIssue,
+    mod_ZodCustomIssue as ZodCustomIssue,
+    mod_DenormalizedError as DenormalizedError,
+    mod_ZodIssueOptionalMessage as ZodIssueOptionalMessage,
+    mod_ZodIssue as ZodIssue,
+    mod_quotelessJson as quotelessJson,
+    mod_ZodFormattedError as ZodFormattedError,
+    mod_ZodError as ZodError,
+    mod_IssueData as IssueData,
+    mod_MakeErrorData as MakeErrorData,
+    mod_ZodErrorMap as ZodErrorMap,
+    mod_defaultErrorMap as defaultErrorMap,
+    mod_overrideErrorMap as overrideErrorMap,
+    mod_setErrorMap as setErrorMap,
   };
 }
 
 declare namespace schema {
   export {
-    external_d as define,
+    mod as define,
   };
 }
 
@@ -3693,6 +5404,19 @@ declare namespace toml {
   };
 }
 
+interface CreateOptions {
+    port: number;
+    authToken: string;
+}
+declare function create(options: CreateOptions): Promise<string>;
+
+declare const tunnel_create: typeof create;
+declare namespace tunnel {
+  export {
+    tunnel_create as create,
+  };
+}
+
 /**
  * JSON Schema
  *
@@ -4588,7 +6312,7 @@ declare enum JSONSchemaContentEncoding {
   XToken = 'x-token'
 }
 
-interface Options<T> {
+interface Options<T extends Record<string, any>> {
     /**
     Config used if there are no existing config.
 
@@ -4794,7 +6518,7 @@ interface Options<T> {
     */
     readonly configFileMode?: number;
 }
-declare type Migrations<T> = Record<string, (store: Conf<T>) => void>;
+declare type Migrations<T extends Record<string, any>> = Record<string, (store: Conf<T>) => void>;
 declare type Schema<T> = {
     [Property in keyof T]: ValueSchema;
 };
@@ -5005,6 +6729,21 @@ interface CreateAppQuerySchema {
     };
 }
 
+declare const UpdateURLsQuery: string;
+interface UpdateURLsQueryVariables {
+    apiKey: string;
+    appUrl: string;
+    redir: string[];
+}
+interface UpdateURLsQuerySchema {
+    appUpdate: {
+        userErrors: {
+            field: string[];
+            message: string;
+        }[];
+    };
+}
+
 declare const index_FindOrganizationQuery: typeof FindOrganizationQuery;
 type index_FindOrganizationQuerySchema = FindOrganizationQuerySchema;
 type index_AllOrganizationsQuerySchema = AllOrganizationsQuerySchema;
@@ -5012,6 +6751,9 @@ declare const index_AllOrganizationsQuery: typeof AllOrganizationsQuery;
 declare const index_CreateAppQuery: typeof CreateAppQuery;
 type index_CreateAppQueryVariables = CreateAppQueryVariables;
 type index_CreateAppQuerySchema = CreateAppQuerySchema;
+declare const index_UpdateURLsQuery: typeof UpdateURLsQuery;
+type index_UpdateURLsQueryVariables = UpdateURLsQueryVariables;
+type index_UpdateURLsQuerySchema = UpdateURLsQuerySchema;
 declare namespace index {
   export {
     index_FindOrganizationQuery as FindOrganizationQuery,
@@ -5021,6 +6763,9 @@ declare namespace index {
     index_CreateAppQuery as CreateAppQuery,
     index_CreateAppQueryVariables as CreateAppQueryVariables,
     index_CreateAppQuerySchema as CreateAppQuerySchema,
+    index_UpdateURLsQuery as UpdateURLsQuery,
+    index_UpdateURLsQueryVariables as UpdateURLsQueryVariables,
+    index_UpdateURLsQuerySchema as UpdateURLsQuerySchema,
   };
 }
 
@@ -5307,5 +7052,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, tunnel, ui, version };
 //# sourceMappingURL=index.d.ts.map