@cmflow/cli 3.4.0-beta.30 → 3.4.0-beta.31

package/dist/index.d.mts

@@ -1,16 +1,15 @@
 
 /// <reference path="operators/index.d.ts" />
 /// <reference path="testing/index.d.ts" />
-/// <reference types="node"/>
 import { a as SemanticContext, c as getConfig, i as CmContext, l as PackageJson, n as CommandConstructor, o as CliConfig, r as ICommand, s as getCI, t as CmTask } from "./index-B7dZdFg6.mjs";
-import { ChildProcess } from "child_process";
-import { Readable, Stream } from "stream";
-import { NextRelease, Options as Options$1 } from "semantic-release";
+import { ChildProcess } from "node:child_process";
+import { SignalConstants } from "node:os";
+import { Duplex, Readable, Writable } from "node:stream";
+import { NextRelease, Options } from "semantic-release";
+import { ReadableStream, ReadableWritablePair, TransformStream, WritableStream } from "node:stream/web";
 //#region ../../node_modules/commander/typings/index.d.ts
 // Type definitions for commander
 // Original definitions by: Alan Agius <https://github.com/alan-agius4>, Marcelo Dezem <https://github.com/mdezem>, vvakame <https://github.com/vvakame>, Jules Randolph <https://github.com/sveinburne>
-// Using method rather than property for method-signature-style, to document method overloads separately. Allow either.
-/* eslint-disable @typescript-eslint/method-signature-style */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 // This is a trick to encourage editor to suggest the known literals while still
 // allowing any BaseType value.
@@ -45,6 +44,7 @@ declare class Argument {
   variadic: boolean;
   defaultValue?: any;
   defaultValueDescription?: string;
+  parseArg?: <T>(value: string, previous: T) => T;
   argChoices?: string[];
   /**
    * Initialize a new command argument with the given name and description.
@@ -94,6 +94,7 @@ declare class Option {
   parseArg?: <T>(value: string, previous: T) => T;
   hidden: boolean;
   argChoices?: string[];
+  helpGroupHeading?: string;
   constructor(flags: string, description?: string);
   /**
    * Set the default value, and optionally supply the description to be displayed in the help.
@@ -161,9 +162,13 @@ declare class Option {
   name(): string;
   /**
    * Return option name, in a camelcase format that can be used
-   * as a object attribute key.
+   * as an object attribute key.
    */
   attributeName(): string;
+  /**
+   * Set the help group heading.
+   */
+  helpGroup(heading: string): this;
   /**
    * Return whether a boolean option.
    *
@@ -174,10 +179,22 @@ declare class Option {
 declare class Help {
   /** output helpWidth, long lines are wrapped to fit */
   helpWidth?: number;
+  minWidthToWrap: number;
   sortSubcommands: boolean;
   sortOptions: boolean;
   showGlobalOptions: boolean;
   constructor();
+  /*
+   * prepareContext is called by Commander after applying overrides from `Command.configureHelp()`
+   * and just before calling `formatHelp()`.
+   *
+   * Commander just uses the helpWidth and the others are provided for subclasses.
+   */
+  prepareContext(contextOptions: {
+    error?: boolean;
+    helpWidth?: number;
+    outputHasColors?: boolean;
+  }): void;
   /** Get the command term to show in the list of subcommands. */
   subcommandTerm(cmd: Command): string;
   /** Get the command summary to show in the list of subcommands. */
@@ -210,13 +227,54 @@ declare class Help {
   longestGlobalOptionTermLength(cmd: Command, helper: Help): number;
   /** Get the longest argument term length. */
   longestArgumentTermLength(cmd: Command, helper: Help): number;
+  /** Return display width of string, ignoring ANSI escape sequences. Used in padding and wrapping calculations. */
+  displayWidth(str: string): number;
+  /** Style the titles. Called with 'Usage:', 'Options:', etc. */
+  styleTitle(title: string): string;
+  /** Usage: <str> */
+  styleUsage(str: string): string;
+  /** Style for command name in usage string.  */
+  styleCommandText(str: string): string;
+  styleCommandDescription(str: string): string;
+  styleOptionDescription(str: string): string;
+  styleSubcommandDescription(str: string): string;
+  styleArgumentDescription(str: string): string;
+  /** Base style used by descriptions. */
+  styleDescriptionText(str: string): string;
+  styleOptionTerm(str: string): string;
+  styleSubcommandTerm(str: string): string;
+  styleArgumentTerm(str: string): string;
+  /** Base style used in terms and usage for options. */
+  styleOptionText(str: string): string;
+  /** Base style used in terms and usage for subcommands. */
+  styleSubcommandText(str: string): string;
+  /** Base style used in terms and usage for arguments. */
+  styleArgumentText(str: string): string;
   /** Calculate the pad width from the maximum term length. */
   padWidth(cmd: Command, helper: Help): number;
   /**
-   * Wrap the given string to width characters per line, with lines after the first indented.
-   * Do not wrap if insufficient room for wrapping (minColumnWidth), or string is manually formatted.
+   * Wrap a string at whitespace, preserving existing line breaks.
+   * Wrapping is skipped if the width is less than `minWidthToWrap`.
+   */
+  boxWrap(str: string, width: number): string;
+  /** Detect manually wrapped and indented strings by checking for line break followed by whitespace. */
+  preformatted(str: string): boolean;
+  /**
+   * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines.
+   *
+   * So "TTT", 5, "DDD DDDD DD DDD" might be formatted for this.helpWidth=17 like so:
+   *   TTT    DDD DDDD
+   *          DD DDD
+   */
+  formatItem(term: string, termWidth: number, description: string, helper: Help): string;
+  /**
+   * Format a list of items, given a heading and an array of formatted items.
+   */
+  formatItemList(heading: string, items: string[], helper: Help): string[];
+  /**
+   * Group items by their help group heading.
    */
-  wrap(str: string, width: number, indent: number, minColumnWidth?: number): string;
+  groupItems<T extends Command | Option>(unsortedItems: T[], visibleItems: T[], getGroup: (item: T) => string): Map<string, T[]>;
   /** Generate the built-in help text. */
   formatHelp(cmd: Command, helper: Help): string;
 }
@@ -236,9 +294,12 @@ interface AddHelpTextContext {
 interface OutputConfiguration {
   writeOut?(str: string): void;
   writeErr?(str: string): void;
+  outputError?(str: string, write: (str: string) => void): void;
   getOutHelpWidth?(): number;
   getErrHelpWidth?(): number;
-  outputError?(str: string, write: (str: string) => void): void;
+  getOutHasColors?(): boolean;
+  getErrHasColors?(): boolean;
+  stripColor?(str: string): string;
 }
 type AddHelpTextPosition = 'beforeAll' | 'before' | 'after' | 'afterAll';
 type HookEvent = 'preSubcommand' | 'preAction' | 'postAction';
@@ -342,7 +403,7 @@ declare class Command {
    *
    * @returns `this` command for chaining
    */
-  argument<T>(flags: string, description: string, fn: (value: string, previous: T) => T, defaultValue?: T): this;
+  argument<T>(flags: string, description: string, parseArg: (value: string, previous: T) => T, defaultValue?: T): this;
   argument(name: string, description?: string, defaultValue?: unknown): this;
   /**
    * Define argument syntax for command, adding a prepared argument.
@@ -456,7 +517,7 @@ declare class Command {
    *
    * @returns `this` command for chaining
    */
-  action(fn: (...args: any[]) => void | Promise<void>): this;
+  action(fn: (this: this, ...args: any[]) => void | Promise<void>): this;
   /**
    * Define option with `flags`, `description`, and optional argument parsing function or `defaultValue` or both.
    *
@@ -470,7 +531,7 @@ declare class Command {
    * ```js
    * program
    *     .option('-p, --pepper', 'add pepper')
-   *     .option('-p, --pizza-type <TYPE>', 'type of pizza') // required option-argument
+   *     .option('--pt, --pizza-type <TYPE>', 'type of pizza') // required option-argument
    *     .option('-c, --cheese [CHEESE]', 'add extra cheese', 'mozzarella') // optional option-argument with default
    *     .option('-t, --tip <VALUE>', 'add tip to purchase cost', parseFloat) // custom parse function
    * ```
@@ -619,10 +680,26 @@ declare class Command {
    * @returns Promise
    */
   parseAsync(argv?: readonly string[], parseOptions?: ParseOptions): Promise<this>;
+  /**
+   * Called the first time parse is called to save state and allow a restore before subsequent calls to parse.
+   * Not usually called directly, but available for subclasses to save their custom state.
+   *
+   * This is called in a lazy way. Only commands used in parsing chain will have state saved.
+   */
+  saveStateBeforeParse(): void;
+  /**
+   * Restore state before parse for calls after the first.
+   * Not usually called directly, but available for subclasses to save their custom state.
+   *
+   * This is called in a lazy way. Only commands used in parsing chain will have state restored.
+   */
+  restoreStateBeforeParse(): void;
   /**
    * Parse options from `argv` removing known options,
    * and return argv split into operands and unknown arguments.
    *
+   * Side effects: modifies command by storing options. Does not reset state if called again.
+   *
    *     argv => operands, unknown
    *     --known kkk op => [op], []
    *     op --known kkk => [op], []
@@ -706,13 +783,13 @@ declare class Command {
   name(): string;
   /**
    * Set the name of the command from script filename, such as process.argv[1],
-   * or require.main.filename, or __filename.
+   * or import.meta.filename.
    *
    * (Used internally and public although not documented in README.)
    *
    * @example
    * ```ts
-   * program.nameFromFilename(require.main.filename);
+   * program.nameFromFilename(import.meta.filename);
    * ```
    *
    * @returns `this` command for chaining
@@ -723,7 +800,7 @@ declare class Command {
    *
    * @example
    * ```ts
-   * program.executableDir(__dirname);
+   * program.executableDir(import.meta.dirname);
    * // or
    * program.executableDir('subcommands');
    * ```
@@ -735,6 +812,50 @@ declare class Command {
    * Get the executable search directory.
    */
   executableDir(): string | null;
+  /**
+   * Set the help group heading for this subcommand in parent command's help.
+   *
+   * @returns `this` command for chaining
+   */
+  helpGroup(heading: string): this;
+  /**
+   * Get the help group heading for this subcommand in parent command's help.
+   */
+  helpGroup(): string;
+  /**
+   * Set the default help group heading for subcommands added to this command.
+   * (This does not override a group set directly on the subcommand using .helpGroup().)
+   *
+   * @example
+   * program.commandsGroup('Development Commands:);
+   * program.command('watch')...
+   * program.command('lint')...
+   * ...
+   *
+   * @returns `this` command for chaining
+   */
+  commandsGroup(heading: string): this;
+  /**
+   * Get the default help group heading for subcommands added to this command.
+   */
+  commandsGroup(): string;
+  /**
+   * Set the default help group heading for options added to this command.
+   * (This does not override a group set directly on the option using .helpGroup().)
+   *
+   * @example
+   * program
+   *   .optionsGroup('Development Options:')
+   *   .option('-d, --debug', 'output extra debugging')
+   *   .option('-p, --profile', 'output profiling information')
+   *
+   * @returns `this` command for chaining
+   */
+  optionsGroup(heading: string): this;
+  /**
+   * Get the default help group heading for options added to this command.
+   */
+  optionsGroup(): string;
   /**
    * Output help information for this command.
    *
@@ -743,7 +864,7 @@ declare class Command {
    */
   outputHelp(context?: HelpContext): void;
   /** @deprecated since v7 */
-  outputHelp(cb?: (str: string) => string): void;
+  outputHelp(cb: (str: string) => string): void;
   /**
    * Return command help documentation.
    */
@@ -766,7 +887,7 @@ declare class Command {
    */
   help(context?: HelpContext): never;
   /** @deprecated since v7 */
-  help(cb?: (str: string) => string): never;
+  help(cb: (str: string) => string): never;
   /**
    * Add additional text to be displayed with the built-in help.
    *
@@ -868,12 +989,9 @@ declare class Rebase extends Fetch implements ICommand {
  * method, which will attach a child Subscription to the current Subscription.
  * When a Subscription is unsubscribed, all its children (and its grandchildren)
  * will be unsubscribed as well.
- *
- * @class Subscription
  */
 declare class Subscription implements SubscriptionLike {
   private initialTeardown?;
-  /** @nocollapse */
   static EMPTY: Subscription;
   /**
    * A flag to indicate whether this Subscription has already been unsubscribed.
@@ -894,7 +1012,6 @@ declare class Subscription implements SubscriptionLike {
    * Disposes the resources held by the subscription. May, for instance, cancel
    * an ongoing Observable execution or cancel any other type of work that
    * started when the Subscription was created.
-   * @return {void}
    */
   unsubscribe(): void;
   /**
@@ -1031,8 +1148,6 @@ interface Observer<T> {
  * a Subscriber, in order to provide Subscription-like capabilities such as
  * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for
  * implementing operators, but it is rarely used as a public API.
- *
- * @class Subscriber<T>
  */
 declare class Subscriber<T> extends Subscription implements Observer<T> {
   /**
@@ -1045,7 +1160,6 @@ declare class Subscriber<T> extends Subscription implements Observer<T> {
    * Observer.
    * @return A Subscriber wrapping the (partially defined)
    * Observer represented by the given arguments.
-   * @nocollapse
    * @deprecated Do not use. Will be removed in v8. There is no replacement for this
    * method, and there is no reason to be creating instances of `Subscriber` directly.
    * If you have a specific use case, please file an issue.
@@ -1064,23 +1178,20 @@ declare class Subscriber<T> extends Subscription implements Observer<T> {
    * The {@link Observer} callback to receive notifications of type `next` from
    * the Observable, with a value. The Observable may call this method 0 or more
    * times.
-   * @param {T} [value] The `next` value.
-   * @return {void}
+   * @param value The `next` value.
    */
-  next(value?: T): void;
+  next(value: T): void;
   /**
    * The {@link Observer} callback to receive notifications of type `error` from
    * the Observable, with an attached `Error`. Notifies the Observer that
    * the Observable has experienced an error condition.
-   * @param {any} [err] The `error` exception.
-   * @return {void}
+   * @param err The `error` exception.
    */
   error(err?: any): void;
   /**
    * The {@link Observer} callback to receive a valueless notification of type
    * `complete` from the Observable. Notifies the Observer that the Observable
    * has finished sending push-based notifications.
-   * @return {void}
    */
   complete(): void;
   unsubscribe(): void;
@@ -1101,8 +1212,6 @@ interface Operator<T, R> {
 /**
  * A representation of any set of values over any amount of time. This is the most basic building block
  * of RxJS.
- *
- * @class Observable<T>
  */
 declare class Observable<T> implements Subscribable<T> {
   /**
@@ -1114,8 +1223,7 @@ declare class Observable<T> implements Subscribable<T> {
    */
   operator: Operator<any, T> | undefined;
   /**
-   * @constructor
-   * @param {Function} subscribe the function that is called when the Observable is
+   * @param subscribe The function that is called when the Observable is
    * initially subscribed to. This function is given a Subscriber, to which new values
    * can be `next`ed, or an `error` method can be called to raise an error, or
    * `complete` can be called to notify of a successful completion.
@@ -1123,20 +1231,16 @@ declare class Observable<T> implements Subscribable<T> {
   constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
   /**
    * Creates a new Observable by calling the Observable constructor
-   * @owner Observable
-   * @method create
-   * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
-   * @return {Observable} a new observable
-   * @nocollapse
+   * @param subscribe the subscriber function to be passed to the Observable constructor
+   * @return A new observable.
    * @deprecated Use `new Observable()` instead. Will be removed in v8.
    */
   static create: (...args: any[]) => any;
   /**
    * Creates a new Observable, with this Observable instance as the source, and the passed
    * operator defined as the new observable's operator.
-   * @method lift
    * @param operator the operator defining the operation to take on the observable
-   * @return a new observable with the Operator applied
+   * @return A new observable with the Operator applied.
    * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
    * If you have implemented an operator using `lift`, it is recommended that you create an
    * operator by simply returning `new Observable()` directly. See "Creating new operators from
@@ -1186,9 +1290,9 @@ declare class Observable<T> implements Subscribable<T> {
    * // 'Total: 6'
    * ```
    *
-   * @param next a handler for each value emitted by the observable
-   * @return a promise that either resolves on observable completion or
-   *  rejects with the handled error
+   * @param next A handler for each value emitted by the observable.
+   * @return A promise that either resolves on observable completion or
+   * rejects with the handled error.
    */
   forEach(next: (value: T) => void): Promise<void>;
   /**
@@ -1332,471 +1436,1563 @@ declare namespace index_d_exports {
 //#region src/commands/release.d.ts
 declare function release(options?: {}): void;
 //#endregion
-//#region ../../node_modules/execa/index.d.ts
-declare namespace execa {
-  type StdioOption = 'pipe' | 'ipc' | 'ignore' | 'inherit' | Stream | number | undefined;
-  interface CommonOptions<EncodingType> {
-    /**
-		Kill the spawned process when the parent process exits unless either:
-			- the spawned process is [`detached`](https://nodejs.org/api/child_process.html#child_process_options_detached)
-			- the parent process is terminated abruptly, for example, with `SIGKILL` as opposed to `SIGTERM` or a normal exit
-
-		@default true
+//#region ../../node_modules/execa/types/utils.d.ts
+type Not<Value extends boolean> = Value extends true ? false : true;
+type And<First extends boolean, Second extends boolean> = First extends true ? Second : false;
+type Unless<Condition extends boolean, ThenValue, ElseValue = never> = Condition extends true ? ElseValue : ThenValue;
+type AndUnless<Condition extends boolean, ThenValue, ElseValue = unknown> = Condition extends true ? ElseValue : ThenValue;
+// Whether any of T's union element is the same as one of U's union element.
+// `&` does not work here.
+type Intersects<T, U> = true extends (T extends U ? true : false) ? true : false;
+//#endregion
+//#region ../../node_modules/execa/types/transform/normalize.d.ts
+// `options.std*: Generator`
+// The `chunk` argument's type is based on the transform's mode:
+// - `binary: true` or binary `encoding`, with `objectMode: true` -> `unknown` for stdin, `Uint8Array` for stdout/stderr
+// - `binary: true` or binary `encoding` -> `Uint8Array`
+// - `objectMode: true` -> `unknown` for stdin, `string` for stdout/stderr
+// - otherwise -> `string`
+// The return type is kept as `unknown` since a transform can always yield either a `string` or an `Uint8Array`.
+// See https://github.com/sindresorhus/execa/issues/694
+type GeneratorTransform<IsSync extends boolean, Chunk = string> = (chunk: Chunk) => Unless<IsSync, AsyncGenerator<unknown, void, void>> | Generator<unknown, void, void>;
+type GeneratorTransformReturn<IsSync extends boolean> = ReturnType<GeneratorTransform<IsSync>>;
+type GeneratorFinal<IsSync extends boolean> = () => Unless<IsSync, AsyncGenerator<unknown, void, void>> | Generator<unknown, void, void>;
+type TransformCommon = {
+  /**
+	If `true`, allow `transformOptions.transform` and `transformOptions.final` to return any type, not just `string` or `Uint8Array`.
+	*/
+  readonly objectMode?: boolean;
+};
+// A `GeneratorTransformFull` shape whose `transform` narrows the `chunk` argument to `Chunk`.
+// The mode-independent documentation lives here.
+type GeneratorTransformBase<IsSync extends boolean, Chunk> = TransformCommon & {
+  /**
+	Map or filter the input or output of the subprocess.
+	*/
+  readonly transform: GeneratorTransform<IsSync, Chunk>;
+  /**
+	Create additional lines after the last one.
+	*/
+  readonly final?: GeneratorFinal<IsSync>;
+  /**
+	If `true`, iterate over arbitrary chunks of `Uint8Array`s instead of line `string`s.
+	*/
+  readonly binary?: boolean;
+  /**
+	If `true`, keep newlines in each `line` argument. Also, this allows multiple `yield`s to produce a single line.
+	*/
+  readonly preserveNewlines?: boolean;
+};
+// For stdout/stderr, this literal option pair accepts explicitly typed `Uint8Array` callbacks, matching runtime binary chunks, while still allowing stdin-style `unknown` object-mode callbacks.
+type GeneratorTransformBinaryObjectMode<IsSync extends boolean, ObjectModeChunk> = ObjectModeChunk extends string ? Omit<GeneratorTransformBase<IsSync, unknown>, 'transform' | 'objectMode' | 'binary'> & {
+  /**
+		Map or filter the input or output of the subprocess.
 		*/
-    readonly cleanup?: boolean;
-    /**
-		Prefer locally installed binaries when looking for a binary to execute.
+  transform(chunk: Uint8Array): GeneratorTransformReturn<IsSync>;
+  // eslint-disable-next-line @typescript-eslint/unified-signatures -- Combining these as `unknown | Uint8Array` would collapse to `unknown` and reject explicitly typed `Uint8Array` callbacks.
+  transform(chunk: unknown): GeneratorTransformReturn<IsSync>;
+  readonly objectMode: true;
+  readonly binary: true;
+} : GeneratorTransformBase<IsSync, unknown> & {
+  readonly objectMode: true;
+  readonly binary: true;
+};
+/**
+A transform or an array of transforms can be passed to the `stdin`, `stdout`, `stderr` or `stdio` option.
+
+A transform is either a generator function or a plain object with the following members.
+*/
+type GeneratorTransformFull<IsSync extends boolean, ObjectModeChunk = unknown, TransformChunk = string> =
+// Non-literal `binary` or `objectMode` values are accepted at runtime, but their mode is unknown at compile time.
+(GeneratorTransformBase<IsSync, unknown> & {
+  readonly objectMode?: boolean;
+  readonly binary?: boolean;
+}) |
+// `binary: true` without `objectMode` -> the `chunk` argument is an `Uint8Array`.
+(GeneratorTransformBase<IsSync, Uint8Array> & {
+  readonly objectMode?: false;
+  readonly binary: true;
+}) |
+// `binary: true` with `objectMode` -> the `chunk` argument is `unknown` for stdin, `Uint8Array` for stdout/stderr.
+GeneratorTransformBinaryObjectMode<IsSync, ObjectModeChunk> |
+// `binary: false` without `objectMode` -> the `chunk` argument depends on the subprocess encoding.
+(GeneratorTransformBase<IsSync, TransformChunk> & {
+  readonly objectMode?: false;
+  readonly binary?: false;
+}) |
+// `objectMode: true` with `binary: false` -> the `chunk` argument depends on the stdio direction.
+(GeneratorTransformBase<IsSync, ObjectModeChunk> & {
+  readonly objectMode: true;
+  readonly binary?: false;
+});
+// `options.std*: Duplex`
+type DuplexTransform = TransformCommon & {
+  readonly transform: Duplex;
+};
+// `options.std*: TransformStream`
+type WebTransform = TransformCommon & {
+  readonly transform: TransformStream;
+};
+//#endregion
+//#region ../../node_modules/execa/types/stdio/type.d.ts
+type IsStandardStream<FdNumber extends string> = FdNumber extends keyof StandardStreams ? true : false;
+type StandardStreams = readonly ['stdin', 'stdout', 'stderr'];
+// When `options.stdin|stdout|stderr|stdio` is set to one of those values, no stream is created
+type NoStreamStdioOption<FdNumber extends string> = 'ignore' | 'inherit' | number | Readable | Writable | Unless<IsStandardStream<FdNumber>, undefined> | readonly [NoStreamStdioOption<FdNumber>] | {
+  readonly value: 'inherit' | number;
+  readonly input?: boolean;
+};
+// `options.stdio` when it is not an array
+type SimpleStdioOption<IsSync extends boolean, IsExtra extends boolean, IsArray extends boolean> = undefined | 'pipe' | Unless<And<And<Not<IsSync>, IsArray>, IsExtra>, 'inherit'> | Unless<IsArray, 'ignore'> | Unless<IsSync, 'overlapped'>;
+// The `{value, input}` object form wraps a direction-ambiguous value and sets its direction explicitly.
+type AmbiguousStdioOption<IsSync extends boolean, IsExtra extends boolean, IsArray extends boolean, ObjectModeChunk = unknown, TransformChunk = string> = {
+  readonly value: AmbiguousStdioValue<IsSync, IsArray, ObjectModeChunk, TransformChunk>;
+  readonly input?: Unless<And<IsSync, IsExtra>, boolean> | false;
+};
+// Values whose direction is ambiguous on additional file descriptors, so they default to output unless `input` is set.
+// This excludes values with a fixed direction (readable/writable streams, iterables, standard file descriptors).
+type AmbiguousStdioValue<IsSync extends boolean, IsArray extends boolean, ObjectModeChunk, TransformChunk> = 'pipe' | 'inherit' | Unless<IsSync, 'overlapped'> | URL | GeneratorTransform<IsSync, TransformChunk> | GeneratorTransformFull<IsSync, ObjectModeChunk, TransformChunk> | Unless<And<Not<IsSync>, IsArray>, 3 | 4 | 5 | 6 | 7 | 8 | 9> | Unless<IsSync, DuplexTransform | WebTransform | TransformStream> | {
+  readonly file: string;
+  readonly append?: boolean;
+};
+// Values available in both `options.stdin|stdio` and `options.stdout|stderr|stdio`
+type CommonStdioOption<IsSync extends boolean, IsExtra extends boolean, IsArray extends boolean, ObjectModeChunk = unknown, TransformChunk = string> =
+// TypeScript cannot contextually type inline full generator transform objects through this broad stdio union because the union also includes `{transform: Duplex | TransformStream}` wrapper objects. Users should annotate `chunk` when assigning an inline object directly to `StdinOption`, `StdoutStderrOption`, `Options['stdout']`, etc. Keep `GeneratorTransformFull` mode branches narrow, but do not add a broad full-object fallback here to try to recover contextual typing.
+SimpleStdioOption<IsSync, IsExtra, IsArray> | URL | GeneratorTransform<IsSync, TransformChunk> | GeneratorTransformFull<IsSync, ObjectModeChunk, TransformChunk> | Unless<And<Not<IsSync>, IsArray>, 3 | 4 | 5 | 6 | 7 | 8 | 9> | Unless<IsSync, DuplexTransform | WebTransform | TransformStream> | AmbiguousStdioOption<IsSync, IsExtra, IsArray, ObjectModeChunk, TransformChunk> | {
+  readonly file: string;
+  readonly append?: boolean;
+};
+// Synchronous iterables excluding strings, Uint8Arrays and Arrays
+type IterableObject<IsArray extends boolean> = Iterable<unknown> & object & AndUnless<IsArray, {
+  readonly lastIndexOf?: never;
+}> & {
+  readonly BYTES_PER_ELEMENT?: never;
+};
+// `process.stdin|stdout|stderr` are `Duplex` with a `fd` property.
+// This ensures they can only be passed to `stdin`/`stdout`/`stderr`, based on their direction.
+type ProcessStdinFd = {
+  readonly fd?: 0;
+};
+type ProcessStdoutStderrFd = {
+  readonly fd?: 1 | 2;
+};
+// Values available only in `options.stdin|stdio`
+type InputStdioOption<IsSync extends boolean = boolean, IsExtra extends boolean = boolean, IsArray extends boolean = boolean> = 0 | Unless<And<IsSync, IsExtra>, Uint8Array | IterableObject<IsArray>> | Unless<And<IsSync, IsArray>, Readable & ProcessStdinFd> | Unless<IsSync, (AsyncIterable<unknown> & ProcessStdinFd) | ReadableStream>;
+// Values available only in `options.stdout|stderr|stdio`
+type OutputStdioOption<IsSync extends boolean, IsArray extends boolean> = 1 | 2 | Unless<And<IsSync, IsArray>, Writable & ProcessStdoutStderrFd> | Unless<IsSync, WritableStream>;
+// `options.stdin` array items
+type StdinSingleOption<IsSync extends boolean, IsExtra extends boolean, IsArray extends boolean, TransformChunk = string> = CommonStdioOption<IsSync, IsExtra, IsArray, unknown, TransformChunk> | InputStdioOption<IsSync, IsExtra, IsArray>;
+// `options.stdin`
+type StdinOptionCommon<IsSync extends boolean = boolean, IsExtra extends boolean = boolean, TransformChunk = string> = TransformChunk extends unknown ? StdinSingleOption<IsSync, IsExtra, false, TransformChunk> | ReadonlyArray<StdinSingleOption<IsSync, IsExtra, true, TransformChunk>> : never;
+// `options.stdout|stderr` array items
+type StdoutStderrSingleOption<IsSync extends boolean, IsExtra extends boolean, IsArray extends boolean, TransformChunk = string> = CommonStdioOption<IsSync, IsExtra, IsArray, TransformChunk, TransformChunk> | OutputStdioOption<IsSync, IsArray>;
+// `options.stdout|stderr`
+// In `objectMode`, the `chunk` argument of every array item is typed as `string`, even though only the first transform in the pipeline receives subprocess lines. The array index cannot be used to infer the pipeline position, since non-transform items are filtered out and transforms are reordered at runtime.
+type StdoutStderrOptionCommon<IsSync extends boolean = boolean, IsExtra extends boolean = boolean, TransformChunk = string> = TransformChunk extends unknown ? StdoutStderrSingleOption<IsSync, IsExtra, false, TransformChunk> | ReadonlyArray<StdoutStderrSingleOption<IsSync, IsExtra, true, TransformChunk>> : never;
+// `options.stdio[3+]`
+type StdioExtraOptionCommon<IsSync extends boolean, TransformChunk = string> = StdinOptionCommon<IsSync, true, TransformChunk> | StdoutStderrOptionCommon<IsSync, true, TransformChunk>;
+// `options.stdin|stdout|stderr|stdio` array items
+type StdioSingleOption<IsSync extends boolean = boolean, IsExtra extends boolean = boolean, IsArray extends boolean = boolean, TransformChunk = string> = StdinSingleOption<IsSync, IsExtra, IsArray, TransformChunk> | StdoutStderrSingleOption<IsSync, IsExtra, IsArray, TransformChunk>;
+// Get `options.stdin|stdout|stderr|stdio` items if it is an array, else keep as is
+type StdioSingleOptionItems<StdioOptionType> = StdioOptionType extends readonly StdioSingleOption[] ? StdioOptionType[number] : StdioOptionType;
+// `options.stdin|stdout|stderr|stdio`
+type StdioOptionCommon<IsSync extends boolean = boolean, TransformChunk = string> = StdinOptionCommon<IsSync, boolean, TransformChunk> | StdoutStderrOptionCommon<IsSync, boolean, TransformChunk>;
+// `options.stdio` when it is an array
+type StdioOptionsArray<IsSync extends boolean = boolean, TransformChunk = string> = readonly [StdinOptionCommon<IsSync, false, TransformChunk>, StdoutStderrOptionCommon<IsSync, false, TransformChunk>, StdoutStderrOptionCommon<IsSync, false, TransformChunk>, ...ReadonlyArray<StdioExtraOptionCommon<IsSync, TransformChunk>>];
+// `options.stdio`
+type StdioOptionsProperty<IsSync extends boolean = boolean, TransformChunk = string> = TransformChunk extends unknown ? SimpleStdioOption<IsSync, false, false> | StdioOptionsArray<IsSync, TransformChunk> : never;
+//#endregion
+//#region ../../node_modules/execa/types/ipc.d.ts
+// Message when the `serialization` option is `'advanced'`
+type AdvancedMessage = string | number | boolean | null | object;
+// Message when the `serialization` option is `'json'`
+type JsonMessage = string | number | boolean | null | readonly JsonMessage[] | {
+  readonly [key: string | number]: JsonMessage;
+};
+/**
+Type of messages exchanged between a process and its subprocess using `sendMessage()`, `getOneMessage()` and `getEachMessage()`.
+
+This requires the `ipc` option to be `true`. The type of `message` depends on the `serialization` option.
+*/
+type Message<Serialization extends Options$1['serialization'] = Options$1['serialization']> = Serialization extends 'json' ? JsonMessage : AdvancedMessage;
+/**
+Options to `sendMessage()` and `subprocess.sendMessage()`
+*/
+type SendMessageOptions = {
+  /**
+	Throw when the other process is not receiving or listening to messages.
+
+	@default false
+	*/
+  readonly strict?: boolean;
+};
+/**
+Options to `getOneMessage()` and `subprocess.getOneMessage()`
+*/
+type GetOneMessageOptions<Serialization extends Options$1['serialization']> = {
+  /**
+	Ignore any `message` that returns `false`.
+	*/
+  readonly filter?: (message: Message<Serialization>) => boolean;
+  /**
+	Keep the subprocess alive while `getOneMessage()` is waiting.
+
+	@default true
+	*/
+  readonly reference?: boolean;
+};
+/**
+Options to `getEachMessage()` and `subprocess.getEachMessage()`
+*/
+type GetEachMessageOptions = {
+  /**
+	Keep the subprocess alive while `getEachMessage()` is waiting.
 
-		If you `$ npm install foo`, you can then `execa('foo')`.
+	@default true
+	*/
+  readonly reference?: boolean;
+};
+// IPC methods in the subprocess
+type IpcMethods<IpcEnabled extends boolean, Serialization extends Options$1['serialization']> = IpcEnabled extends true ? {
+  /**
+		Send a `message` to the subprocess.
 
-		@default false
+		This requires the `ipc` option to be `true`. The type of `message` depends on the `serialization` option.
 		*/
-    readonly preferLocal?: boolean;
-    /**
-		Preferred path to find locally installed binaries in (use with `preferLocal`).
+  sendMessage(message: Message<Serialization>, sendMessageOptions?: SendMessageOptions): Promise<void>;
+  /**
+		Receive a single `message` from the subprocess.
 
-		@default process.cwd()
+		This requires the `ipc` option to be `true`. The type of `message` depends on the `serialization` option.
 		*/
-    readonly localDir?: string;
-    /**
-		Path to the Node.js executable to use in child processes.
+  getOneMessage(getOneMessageOptions?: GetOneMessageOptions<Serialization>): Promise<Message<Serialization>>;
+  /**
+		Iterate over each `message` from the subprocess.
 
-		This can be either an absolute path or a path relative to the `cwd` option.
+		This requires the `ipc` option to be `true`. The type of `message` depends on the `serialization` option.
+		*/
+  getEachMessage(getEachMessageOptions?: GetEachMessageOptions): AsyncIterableIterator<Message<Serialization>>;
+} :
+// Those methods only work if the `ipc` option is `true`.
+// At runtime, they are actually defined, in order to provide with a nice error message.
+// At type check time, they are typed as `undefined` to prevent calling them.
+{
+  sendMessage: undefined;
+  getOneMessage: undefined;
+  getEachMessage: undefined;
+};
+// Whether IPC is enabled, based on the `ipc`, `ipcInput` and `gracefulCancel` options
+type HasIpc<OptionsType extends Options$1> = HasIpcOption<OptionsType['ipc'], 'ipcInput' extends keyof OptionsType ? OptionsType['ipcInput'] : undefined, 'gracefulCancel' extends keyof OptionsType ? OptionsType['gracefulCancel'] : undefined>;
+type HasIpcOption<IpcOption extends Options$1['ipc'], IpcInputOption extends Options$1['ipcInput'], GracefulCancelOption extends Options$1['gracefulCancel']> = IpcOption extends true ? true : IpcOption extends false ? false : IpcInputOption extends undefined ? GracefulCancelOption extends true ? true : false : true;
+//#endregion
+//#region ../../node_modules/execa/types/arguments/fd-options.d.ts
+type FileDescriptorOption = `fd${number}`;
+// `from` option of `subprocess.readable|duplex|iterable|pipe()`
+// Also used by fd-specific options
+type FromOption = 'stdout' | 'stderr' | 'all' | FileDescriptorOption;
+// `to` option of `subprocess.writable|duplex|pipe()`
+type ToOption = 'stdin' | FileDescriptorOption;
+//#endregion
+//#region ../../node_modules/execa/types/arguments/specific.d.ts
+// Options which can be fd-specific like `{verbose: {stdout: 'none', stderr: 'full'}}`
+type FdGenericOption<OptionType> = OptionType | GenericOptionObject<OptionType>;
+type GenericOptionObject<OptionType> = Readonly<Partial<Record<GenericFromOption, OptionType>>>;
+type GenericFromOption = FromOption | 'ipc';
+// Retrieve fd-specific option's value
+type FdSpecificOption<GenericOption extends FdGenericOption<unknown>, FdNumber extends string> = GenericOption extends GenericOptionObject<unknown> ? FdSpecificObjectOption<GenericOption, FdNumber> : GenericOption;
+type FdSpecificObjectOption<GenericOption extends GenericOptionObject<unknown>, FdNumber extends string> = keyof GenericOption extends GenericFromOption ? FdNumberToFromOption<FdNumber, keyof GenericOption> extends never ? undefined : GenericOption[FdNumberToFromOption<FdNumber, keyof GenericOption>] : GenericOption;
+type FdNumberToFromOption<FdNumber extends string, GenericOptionKeys extends GenericFromOption> = FdNumber extends 'ipc' ? 'ipc' extends GenericOptionKeys ? 'ipc' : never : FdNumber extends '1' ? 'stdout' extends GenericOptionKeys ? 'stdout' : 'fd1' extends GenericOptionKeys ? 'fd1' : 'all' extends GenericOptionKeys ? 'all' : never : FdNumber extends '2' ? 'stderr' extends GenericOptionKeys ? 'stderr' : 'fd2' extends GenericOptionKeys ? 'fd2' : 'all' extends GenericOptionKeys ? 'all' : never : `fd${FdNumber}` extends GenericOptionKeys ? `fd${FdNumber}` : never;
+//#endregion
+//#region ../../node_modules/execa/types/return/final-error.d.ts
+// `result.*` defined only on failure, i.e. on `error.*`
+type ErrorProperties = 'name' | 'message' | 'stack' | 'cause' | 'shortMessage' | 'originalMessage' | 'code';
+//#endregion
+//#region ../../node_modules/execa/types/stdio/array.d.ts
+// `options.stdio`, normalized as an array
+type StdioOptionNormalizedArray<OptionsType extends CommonOptions> = StdioOptionNormalized<OptionsType['stdio']>;
+type StdioOptionNormalized<StdioOption extends CommonOptions['stdio']> = StdioOption extends StdioOptionsArray ? StdioOption : StdioOption extends StdinOptionCommon ? StdioOption extends StdoutStderrOptionCommon ? readonly [StdioOption, StdioOption, StdioOption] : DefaultStdioOption : DefaultStdioOption;
+// `options.stdio` default value
+type DefaultStdioOption = readonly ['pipe', 'pipe', 'pipe'];
+//#endregion
+//#region ../../node_modules/execa/types/stdio/option.d.ts
+// `options.stdin|stdout|stderr|stdio` for a given file descriptor
+type FdStdioOption<FdNumber extends string, OptionsType extends CommonOptions> = FdStdioOptionProperty<FdNumber, OptionsType>;
+type FdStdioOptionProperty<FdNumber extends string, OptionsType extends CommonOptions> = string extends FdNumber ? StdioOptionCommon : FdNumber extends keyof StandardStreams ? StandardStreams[FdNumber] extends keyof OptionsType ? OptionsType[StandardStreams[FdNumber]] extends undefined ? FdStdioArrayOption<FdNumber, OptionsType> : OptionsType[StandardStreams[FdNumber]] : FdStdioArrayOption<FdNumber, OptionsType> : FdStdioArrayOption<FdNumber, OptionsType>;
+// `options.stdio[FdNumber]`, excluding `options.stdin|stdout|stderr`
+type FdStdioArrayOption<FdNumber extends string, OptionsType extends CommonOptions> = FdStdioArrayOptionProperty<FdNumber, StdioOptionNormalizedArray<OptionsType>>;
+type FdStdioArrayOptionProperty<FdNumber extends string, StdioOptionsType> = string extends FdNumber ? StdioOptionCommon | undefined : StdioOptionsType extends StdioOptionsArray ? FdNumber extends keyof StdioOptionsType ? StdioOptionsType[FdNumber] : StdioOptionNormalizedArray<CommonOptions> extends StdioOptionsType ? StdioOptionsType[number] : undefined : undefined;
+//#endregion
+//#region ../../node_modules/execa/types/transform/object-mode.d.ts
+// Whether a file descriptor is in object mode
+// I.e. whether `result.stdout|stderr|stdio|all` is an array of `unknown` due to `objectMode: true`
+type IsObjectFd<FdNumber extends string, OptionsType extends CommonOptions> = IsObjectStdioOption<FdStdioOption<FdNumber, OptionsType>>;
+type IsObjectStdioOption<StdioOptionType> = IsObjectStdioSingleOption<StdioSingleOptionItems<StdioOptionType>>;
+type IsObjectStdioSingleOption<StdioSingleOptionType> = StdioSingleOptionType extends TransformCommon ? BooleanObjectMode<StdioSingleOptionType['objectMode']> : StdioSingleOptionType extends DuplexTransform ? StdioSingleOptionType['transform']['readableObjectMode'] : false;
+type BooleanObjectMode<ObjectModeOption extends boolean | undefined> = ObjectModeOption extends true ? true : false;
+//#endregion
+//#region ../../node_modules/execa/types/stdio/direction.d.ts
+type AnyAmbiguousStdioOption = AmbiguousStdioOption<boolean, false, boolean>;
+type InputAmbiguousStdioOption = AnyAmbiguousStdioOption & {
+  readonly input: true;
+};
+type AmbiguousStdioInputValue<StdioOptionType> = StdioOptionType extends AnyAmbiguousStdioOption ? AmbiguousStdioInputProperty<StdioOptionType> : never;
+type AmbiguousStdioInputProperty<StdioOptionType> = 'input' extends keyof StdioOptionType ? StdioOptionType extends {
+  readonly input?: infer Input;
+} ? Input : never : never;
+// Whether `result.stdio[FdNumber]` is an input stream
+type IsInputFd<FdNumber extends string, OptionsType extends CommonOptions> = FdNumber extends '0' ? true : IsInputFdOption<FdNumber, StdioSingleOptionItems<FdStdioArrayOption<FdNumber, OptionsType>>>;
+type IsInputFdOption<FdNumber extends string, StdioOptionType> = Intersects<StdioOptionType, FdNumber extends '1' | '2' ? InputStdioOption : InputStdioOption | InputAmbiguousStdioOption> extends true ? true : FdNumber extends '1' | '2' ? false : true extends AmbiguousStdioInputValue<StdioOptionType> ? boolean : false;
+//#endregion
+//#region ../../node_modules/execa/types/return/ignore.d.ts
+// Whether `result.stdin|stdout|stderr|all|stdio[*]` is `undefined`
+type IgnoresResultOutput<FdNumber extends string, OptionsType extends CommonOptions> = FdSpecificOption<OptionsType['buffer'], FdNumber> extends false ? true : IgnoresResultOutputDirection<IsInputFd<FdNumber, OptionsType>, FdNumber, OptionsType>;
+type IgnoresResultOutputDirection<IsInput extends boolean, FdNumber extends string, OptionsType extends CommonOptions> = IsInput extends true ? true : IgnoresSubprocessOutput<FdNumber, OptionsType>;
+// Whether `subprocess.stdout|stderr|all` is `undefined|null`
+type IgnoresSubprocessOutput<FdNumber extends string, OptionsType extends CommonOptions> = IgnoresOutput<FdNumber, FdStdioOption<FdNumber, OptionsType>>;
+type IgnoresOutput<FdNumber extends string, StdioOptionType> = StdioOptionType extends NoStreamStdioOption<FdNumber> ? true : false;
+//#endregion
+//#region ../../node_modules/execa/types/arguments/encoding-option.d.ts
+type DefaultEncodingOption = 'utf8';
+type TextEncodingOption = DefaultEncodingOption | 'utf16le';
+type BufferEncodingOption = 'buffer';
+type BinaryEncodingOption = BufferEncodingOption | 'hex' | 'base64' | 'base64url' | 'latin1' | 'ascii';
+// `options.encoding`
+type EncodingOption = TextEncodingOption | BinaryEncodingOption | undefined;
+//#endregion
+//#region ../../node_modules/execa/types/return/result-stdout.d.ts
+// `result.stdout|stderr|stdio`
+type ResultStdioNotAll<FdNumber extends string, OptionsType extends CommonOptions> = ResultStdio<FdNumber, FdNumber, FdNumber, OptionsType>;
+// `result.stdout|stderr|stdio|all`
+type ResultStdio<MainFdNumber extends string, ObjectFdNumber extends string, LinesFdNumber extends string, OptionsType extends CommonOptions> = ResultStdioProperty<ObjectFdNumber, LinesFdNumber, IgnoresResultOutput<MainFdNumber, OptionsType>, OptionsType>;
+type ResultStdioProperty<ObjectFdNumber extends string, LinesFdNumber extends string, StreamOutputIgnored, OptionsType extends CommonOptions> = StreamOutputIgnored extends true ? undefined : ResultStdioItem<IsObjectFd<ObjectFdNumber, OptionsType>, FdSpecificOption<OptionsType['lines'], LinesFdNumber>, OptionsType['encoding']>;
+type ResultStdioItem<IsObjectResult, LinesOption extends boolean | undefined, Encoding extends CommonOptions['encoding']> = IsObjectResult extends true ? unknown[] : Encoding extends BufferEncodingOption ? Uint8Array : LinesOption extends true ? Encoding extends BinaryEncodingOption ? string : string[] : string;
+//#endregion
+//#region ../../node_modules/execa/types/return/result-all.d.ts
+// `result.all`
+type ResultAll<OptionsType extends CommonOptions> = ResultAllProperty<OptionsType['all'], OptionsType>;
+type ResultAllProperty<AllOption extends CommonOptions['all'], OptionsType extends CommonOptions> = AllOption extends true ? ResultStdio<AllMainFd<OptionsType>, AllObjectFd<OptionsType>, AllLinesFd<OptionsType>, OptionsType> : undefined;
+type AllMainFd<OptionsType extends CommonOptions> = IgnoresResultOutput<'1', OptionsType> extends true ? '2' : '1';
+type AllObjectFd<OptionsType extends CommonOptions> = IsObjectFd<'1', OptionsType> extends true ? '1' : '2';
+type AllLinesFd<OptionsType extends CommonOptions> = FdSpecificOption<OptionsType['lines'], '1'> extends true ? '1' : '2';
+//#endregion
+//#region ../../node_modules/execa/types/return/result-stdio.d.ts
+// `result.stdio`
+type ResultStdioArray<OptionsType extends CommonOptions> = MapResultStdio<StdioOptionNormalizedArray<OptionsType>, OptionsType>;
+type MapResultStdio<StdioOptionsArrayType, OptionsType extends CommonOptions> = { -readonly [FdNumber in keyof StdioOptionsArrayType]: ResultStdioNotAll<FdNumber extends string ? FdNumber : string, OptionsType>; };
+//#endregion
+//#region ../../node_modules/execa/types/return/result-ipc.d.ts
+// `result.ipcOutput`
+// This is empty unless the `ipc` option is `true`.
+// Also, this is empty if the `buffer` option is `false`.
+type ResultIpcOutput<IsSync, OptionsType extends CommonOptions> = IsSync extends true ? [] : ResultIpcAsync<FdSpecificOption<OptionsType['buffer'], 'ipc'>, HasIpc<StricterOptions<OptionsType, Options$1>>, OptionsType['serialization']>;
+type ResultIpcAsync<BufferOption extends boolean | undefined, IpcEnabled extends boolean, SerializationOption extends CommonOptions['serialization']> = BufferOption extends false ? [] : IpcEnabled extends true ? Array<Message<SerializationOption>> : [];
+//#endregion
+//#region ../../node_modules/execa/types/return/result.d.ts
+declare abstract class CommonResult<IsSync extends boolean, OptionsType extends CommonOptions> {
+  /**
+	The output of the subprocess on [`stdout`](https://en.wikipedia.org/wiki/Standard_streams#Standard_output_(stdout)).
 
-		Requires `preferLocal` to be `true`.
+	This is `undefined` if the `stdout` option is set to only `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
 
-		For example, this can be used together with [`get-node`](https://github.com/ehmicky/get-node) to run a specific Node.js version in a child process.
+	This is an array if the `lines` option is `true`, or if the `stdout` option is a transform in object mode.
+	*/
+  stdout: ResultStdioNotAll<'1', OptionsType>;
+  /**
+	The output of the subprocess on [`stderr`](https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)).
 
-		@default process.execPath
-		*/
-    readonly execPath?: string;
-    /**
-		Buffer the output from the spawned process. When set to `false`, you must read the output of `stdout` and `stderr` (or `all` if the `all` option is `true`). Otherwise the returned promise will not be resolved/rejected.
+	This is `undefined` if the `stderr` option is set to only `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
 
-		If the spawned process fails, `error.stdout`, `error.stderr`, and `error.all` will contain the buffered data.
+	This is an array if the `lines` option is `true`, or if the `stderr` option is a transform in object mode.
+	*/
+  stderr: ResultStdioNotAll<'2', OptionsType>;
+  /**
+	The output of the subprocess with `result.stdout` and `result.stderr` interleaved.
 
-		@default true
-		*/
-    readonly buffer?: boolean;
-    /**
-		Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+	This requires the `all` option to be `true`.
 
-		@default 'pipe'
-		*/
-    readonly stdin?: StdioOption;
-    /**
-		Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+	This is `undefined` if both `stdout` and `stderr` options are set to only `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
 
-		@default 'pipe'
-		*/
-    readonly stdout?: StdioOption;
-    /**
-		Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+	This is an array if the `lines` option is `true`, or if either the `stdout` or `stderr` option is a transform in object mode.
+	*/
+  all: ResultAll<OptionsType>;
+  /**
+	The output of the subprocess on `stdin`, `stdout`, `stderr` and other file descriptors.
 
-		@default 'pipe'
-		*/
-    readonly stderr?: StdioOption;
-    /**
-		Setting this to `false` resolves the promise with the error instead of rejecting it.
+	Items are `undefined` when their corresponding `stdio` option is set to only `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
 
-		@default true
-		*/
-    readonly reject?: boolean;
-    /**
-		Add an `.all` property on the promise and the resolved value. The property contains the output of the process with `stdout` and `stderr` interleaved.
+	Items are arrays when their corresponding `stdio` option is a transform in object mode.
+	*/
+  stdio: ResultStdioArray<OptionsType>;
+  /**
+	All the messages sent by the subprocess to the current process.
 
-		@default false
-		*/
-    readonly all?: boolean;
-    /**
-		Strip the final [newline character](https://en.wikipedia.org/wiki/Newline) from the output.
+	This is empty unless the `ipc` option is `true`. Also, this is empty if the `buffer` option is `false`.
+	*/
+  ipcOutput: ResultIpcOutput<IsSync, OptionsType>;
+  /**
+	Results of the other subprocesses that were piped into this subprocess.
 
-		@default true
-		*/
-    readonly stripFinalNewline?: boolean;
-    /**
-		Set to `false` if you don't want to extend the environment variables when providing the `env` property.
+	This array is initially empty and is populated each time the `subprocess.pipe()` method resolves.
+	*/
+  pipedFrom: Unless<IsSync, Result[], []>;
+  /**
+	The file and arguments that were run.
+	*/
+  command: string;
+  /**
+	Same as `command` but escaped.
+	*/
+  escapedCommand: string;
+  /**
+	The current directory in which the command was run.
+	*/
+  cwd: string;
+  /**
+	Duration of the subprocess, in milliseconds.
+	*/
+  durationMs: number;
+  /**
+	Whether the subprocess failed to run.
 
-		@default true
-		*/
-    readonly extendEnv?: boolean;
-    /**
-		Current working directory of the child process.
+	When this is `true`, the result is an `ExecaError` instance with additional error-related properties.
+	*/
+  failed: boolean;
+  /**
+	Whether the subprocess timed out due to the `timeout` option.
+	*/
+  timedOut: boolean;
+  /**
+	Whether the subprocess was canceled using the `cancelSignal` option.
+	*/
+  isCanceled: boolean;
+  /**
+	Whether the subprocess was canceled using both the `cancelSignal` and the `gracefulCancel` options.
+	*/
+  isGracefullyCanceled: boolean;
+  /**
+	Whether the subprocess failed because its output was larger than the `maxBuffer` option.
+	*/
+  isMaxBuffer: boolean;
+  /**
+	Whether the subprocess was terminated by a signal (like `SIGTERM`) sent by either:
+	- The current process.
+	- Another process. This case is [not supported on Windows](https://nodejs.org/api/process.html#signal-events).
+	*/
+  isTerminated: boolean;
+  /**
+	Whether the subprocess was terminated by the `SIGKILL` signal sent by the `forceKillAfterDelay` option.
+	*/
+  isForcefullyTerminated: boolean;
+  /**
+	The numeric [exit code](https://en.wikipedia.org/wiki/Exit_status) of the subprocess that was run.
 
-		@default process.cwd()
-		*/
-    readonly cwd?: string;
-    /**
-		Environment key-value pairs. Extends automatically from `process.env`. Set `extendEnv` to `false` if you don't want this.
+	This is `undefined` when the subprocess could not be spawned or was terminated by a signal.
+	*/
+  exitCode?: number;
+  /**
+	The name of the signal (like `SIGTERM`) that terminated the subprocess, sent by either:
+	- The current process.
+	- Another process. This case is [not supported on Windows](https://nodejs.org/api/process.html#signal-events).
 
-		@default process.env
-		*/
-    readonly env?: NodeJS.ProcessEnv;
-    /**
-		Explicitly set the value of `argv[0]` sent to the child process. This will be set to `command` or `file` if not specified.
-		*/
-    readonly argv0?: string;
-    /**
-		Child's [stdio](https://nodejs.org/api/child_process.html#child_process_options_stdio) configuration.
+	If a signal terminated the subprocess, this property is defined and included in the error message. Otherwise it is `undefined`.
+	*/
+  signal?: keyof SignalConstants;
+  /**
+	A human-friendly description of the signal that was used to terminate the subprocess.
 
-		@default 'pipe'
-		*/
-    readonly stdio?: 'pipe' | 'ignore' | 'inherit' | readonly StdioOption[];
-    /**
-		Specify the kind of serialization used for sending messages between processes when using the `stdio: 'ipc'` option or `execa.node()`:
-			- `json`: Uses `JSON.stringify()` and `JSON.parse()`.
-			- `advanced`: Uses [`v8.serialize()`](https://nodejs.org/api/v8.html#v8_v8_serialize_value)
+	If a signal terminated the subprocess, 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;
+  /**
+	Error message when the subprocess failed to run.
+	*/
+  message?: string;
+  /**
+	This is the same as `error.message` except it does not include the subprocess output.
+	*/
+  shortMessage?: string;
+  /**
+	Original error message. This is the same as `error.message` excluding the subprocess output and some additional information added by Execa.
 
-		Requires Node.js `13.2.0` or later.
+	This exists only in specific instances, such as during a timeout.
+	*/
+  originalMessage?: string;
+  /**
+	Underlying error, if there is one. For example, this is set by `subprocess.kill(error)`.
 
-		[More info.](https://nodejs.org/api/child_process.html#child_process_advanced_serialization)
+	This is usually an `Error` instance.
+	*/
+  cause?: unknown;
+  /**
+	Node.js-specific [error code](https://nodejs.org/api/errors.html#errorcode), when available.
+	*/
+  code?: string;
+  // We cannot `extend Error` because `message` must be optional. So we copy its types here.
+  readonly name?: Error['name'];
+  stack?: Error['stack'];
+}
+type SuccessResult<IsSync extends boolean = boolean, OptionsType extends CommonOptions = CommonOptions> = InstanceType<typeof CommonResult<IsSync, OptionsType>> & OmitErrorIfReject<OptionsType['reject']>;
+type OmitErrorIfReject<RejectOption extends CommonOptions['reject']> = Record<ErrorProperties, RejectOption extends false ? unknown : never>;
+/**
+Result of a subprocess successful execution.
 
-		@default 'json'
-		*/
-    readonly serialization?: 'json' | 'advanced';
-    /**
-		Prepare child to run independently of its parent process. Specific behavior [depends on the platform](https://nodejs.org/api/child_process.html#child_process_options_detached).
+When the subprocess fails, it is rejected with an `ExecaError` instead.
+*/
+type Result<OptionsType extends Options$1 = Options$1> = SuccessResult<false, OptionsType>;
+/**
+Result of a subprocess successful execution.
 
-		@default false
-		*/
-    readonly detached?: boolean;
-    /**
-		Sets the user identity of the process.
-		*/
-    readonly uid?: number;
-    /**
-		Sets the group identity of the process.
-		*/
-    readonly gid?: number;
-    /**
-		If `true`, runs `command` inside of a shell. Uses `/bin/sh` on UNIX and `cmd.exe` on Windows. A different shell can be specified as a string. The shell should understand the `-c` switch on UNIX or `/d /s /c` on Windows.
+When the subprocess fails, it is rejected with an `ExecaError` instead.
+*/
+type SyncResult<OptionsType extends SyncOptions = SyncOptions> = SuccessResult<true, OptionsType>;
+//#endregion
+//#region ../../node_modules/execa/types/verbose.d.ts
+type VerboseOption = FdGenericOption<'none' | 'short' | 'full' | VerboseFunction>;
+type VerboseFunction = (verboseLine: string, verboseObject: MinimalVerboseObject) => string | void;
+type GenericVerboseObject = {
+  /**
+	Event type. This can be:
+	- `'command'`: subprocess start
+	- `'output'`: `stdout`/`stderr` output
+	- `'ipc'`: IPC output
+	- `'error'`: subprocess failure
+	- `'duration'`: subprocess success or failure
+	*/
+  type: 'command' | 'output' | 'ipc' | 'error' | 'duration';
+  /**
+	Depending on `verboseObject.type`, this is:
+	- `'command'`: the `result.escapedCommand`
+	- `'output'`: one line from `result.stdout` or `result.stderr`
+	- `'ipc'`: one IPC message from `result.ipcOutput`
+	- `'error'`: the `error.shortMessage`
+	- `'duration'`: the `result.durationMs`
+	*/
+  message: string;
+  /**
+	The file and arguments that were run. This is the same as `result.escapedCommand`.
+	*/
+  escapedCommand: string;
+  /**
+	Serial number identifying the subprocess within the current process. It is incremented from `'0'`.
 
-		We recommend against using this option since it is:
-		- not cross-platform, encouraging shell-specific syntax.
-		- slower, because of the additional shell interpretation.
-		- unsafe, potentially allowing command injection.
+	This is helpful when multiple subprocesses are running at the same time.
 
-		@default false
-		*/
-    readonly shell?: boolean | string;
-    /**
-		Specify the character encoding used to decode the `stdout` and `stderr` output. If set to `null`, then `stdout` and `stderr` will be a `Buffer` instead of a string.
+	This is similar to a [PID](https://en.wikipedia.org/wiki/Process_identifier) except it has no maximum limit, which means it never repeats. Also, it is usually shorter.
+	*/
+  commandId: string;
+  /**
+	Event date/time.
+	*/
+  timestamp: Date;
+  /**
+	Whether another subprocess is piped into this subprocess. This is `false` when `result.pipedFrom` is empty.
+	*/
+  piped: boolean;
+};
+type MinimalVerboseObject = GenericVerboseObject & {
+  // We cannot use the `CommonOptions` type because it would make this type recursive
+  options: object;
+  result?: never;
+};
+//#endregion
+//#region ../../node_modules/execa/types/arguments/options.d.ts
+type ChunkForEncoding<Encoding extends EncodingOption> = Encoding extends BinaryEncodingOption ? Uint8Array : string;
+type CommonOptions<IsSync extends boolean = boolean, Encoding extends EncodingOption = EncodingOption> = {
+  /**
+	Prefer locally installed binaries when looking for a binary to execute.
 
-		@default 'utf8'
-		*/
-    readonly encoding?: EncodingType;
-    /**
-		If `timeout` is greater than `0`, the parent will send the signal identified by the `killSignal` property (the default is `SIGTERM`) if the child runs longer than `timeout` milliseconds.
+	@default `true` with `$`, `false` otherwise
+	*/
+  readonly preferLocal?: boolean;
+  /**
+	Preferred path to find locally installed binaries, when using the `preferLocal` option.
 
-		@default 0
-		*/
-    readonly timeout?: number;
-    /**
-		Largest amount of data in bytes allowed on `stdout` or `stderr`. Default: 100 MB.
+	@default `cwd` option
+	*/
+  readonly localDir?: string | URL;
+  /**
+	If `true`, runs with Node.js. The first argument must be a Node.js file.
 
-		@default 100_000_000
-		*/
-    readonly maxBuffer?: number;
-    /**
-		Signal value to be used when the spawned process will be killed.
+	The subprocess inherits the current Node.js [CLI flags](https://nodejs.org/api/cli.html#options) and version. This can be overridden using the `nodeOptions` and `nodePath` options.
 
-		@default 'SIGTERM'
-		*/
-    readonly killSignal?: string | number;
-    /**
-		If `true`, no quoting or escaping of arguments is done on Windows. Ignored on other platforms. This is set to `true` automatically when the `shell` option is `true`.
+	@default `true` with `execaNode()`, `false` otherwise
+	*/
+  readonly node?: boolean;
+  /**
+	List of [CLI flags](https://nodejs.org/api/cli.html#cli_options) passed to the Node.js executable.
 
-		@default false
-		*/
-    readonly windowsVerbatimArguments?: boolean;
-    /**
-		On Windows, do not create a new console window. Please note this also prevents `CTRL-C` [from working](https://github.com/nodejs/node/issues/29837) on Windows.
+	Requires the `node` option to be `true`.
 
-		@default true
-		*/
-    readonly windowsHide?: boolean;
-  }
-  interface Options<EncodingType = string> extends CommonOptions<EncodingType> {
-    /**
-		Write some input to the `stdin` of your binary.
-		*/
-    readonly input?: string | Buffer | Readable;
-  }
-  interface SyncOptions<EncodingType = string> extends CommonOptions<EncodingType> {
-    /**
-		Write some input to the `stdin` of your binary.
-		*/
-    readonly input?: string | Buffer;
-  }
-  interface NodeOptions<EncodingType = string> extends Options<EncodingType> {
-    /**
-		The Node.js executable to use.
+	@default [`process.execArgv`](https://nodejs.org/api/process.html#process_process_execargv) (current Node.js CLI flags)
+	*/
+  readonly nodeOptions?: readonly string[];
+  /**
+	Path to the Node.js executable.
 
-		@default process.execPath
-		*/
-    readonly nodePath?: string;
-    /**
-		List of [CLI options](https://nodejs.org/api/cli.html#cli_options) passed to the Node.js executable.
+	Requires the `node` option to be `true`.
 
-		@default process.execArgv
-		*/
-    readonly nodeOptions?: string[];
-  }
-  interface ExecaReturnBase<StdoutStderrType> {
-    /**
-		The file and arguments that were run, for logging purposes.
+	@default [`process.execPath`](https://nodejs.org/api/process.html#process_process_execpath) (current Node.js executable)
+	*/
+  readonly nodePath?: string | URL;
+  /**
+	If `true`, runs the command inside of a [shell](https://en.wikipedia.org/wiki/Shell_(computing)).
 
-		This is not escaped and should not be executed directly as a process, including using `execa()` or `execa.command()`.
-		*/
-    command: string;
-    /**
-		Same as `command` but escaped.
+	Uses [`/bin/sh`](https://en.wikipedia.org/wiki/Unix_shell) on UNIX and [`cmd.exe`](https://en.wikipedia.org/wiki/Cmd.exe) on Windows. A different shell can be specified as a string. The shell should understand the `-c` switch on UNIX or `/d /s /c` on Windows.
 
-		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 `execa.command()`.
-		*/
-    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`.
+	We recommend against using this option.
 
-		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`.
+	@default false
+	*/
+  readonly shell?: boolean | string | URL;
+  /**
+	Current [working directory](https://en.wikipedia.org/wiki/Working_directory) of the subprocess.
 
-		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> {}
+	This is also used to resolve the `nodePath` option when it is a relative path.
+
+	@default process.cwd()
+	*/
+  readonly cwd?: string | URL;
   /**
-	Result of a child process execution. On success this is a plain object. On failure this is also an `Error` instance.
+	[Environment variables](https://en.wikipedia.org/wiki/Environment_variable).
+
+	Unless the `extendEnv` option is `false`, the subprocess also uses the current process' environment variables ([`process.env`](https://nodejs.org/api/process.html#processenv)).
 
-	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
+	@default [process.env](https://nodejs.org/api/process.html#processenv)
 	*/
-  interface ExecaReturnValue<StdoutErrorType = string> extends ExecaSyncReturnValue<StdoutErrorType> {
-    /**
-		The output of the process with `stdout` and `stderr` interleaved.
+  readonly env?: Readonly<Partial<Record<string, string>>>;
+  /**
+	If `true`, the subprocess uses both the `env` option and the current process' environment variables ([`process.env`](https://nodejs.org/api/process.html#processenv)).
+	If `false`, only the `env` option is used, not `process.env`.
 
-		This is `undefined` if either:
-		- the `all` option is `false` (default value)
-		- `execa.sync()` was used
-		*/
-    all?: StdoutErrorType;
-    /**
-		Whether the process was canceled.
-		*/
-    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.
+	@default true
+	*/
+  readonly extendEnv?: boolean;
+  /**
+	Write some input to the subprocess' [`stdin`](https://en.wikipedia.org/wiki/Standard_streams#Standard_input_(stdin)).
 
-		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.
+	See also the `inputFile` and `stdin` options.
+	*/
+  readonly input?: string | Uint8Array | Readable;
+  /**
+	Use a file as input to the subprocess' [`stdin`](https://en.wikipedia.org/wiki/Standard_streams#Standard_input_(stdin)).
 
-		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.
+	See also the `input` and `stdin` options.
+	*/
+  readonly inputFile?: string | URL;
+  /**
+	How to setup the subprocess' [standard input](https://en.wikipedia.org/wiki/Standard_streams#Standard_input_(stdin)). This can be `'pipe'`, `'overlapped'`, `'ignore`, `'inherit'`, a file descriptor integer, a Node.js `Readable` stream, a web `ReadableStream`, a `{ file: 'path' }` object, a file URL, an `Iterable`, an `AsyncIterable`, an `Uint8Array`, a generator function, a `Duplex` or a web `TransformStream`.
 
-		This is `undefined` if either:
-		- the `all` option is `false` (default value)
-		- `execa.sync()` 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`.
+	This can be an array of values such as `['inherit', 'pipe']` or `[fileUrl, 'pipe']`.
 
-		Can be disabled with `false`.
+	@default `'inherit'` with `$`, `'pipe'` otherwise
+	*/
+  readonly stdin?: StdinOptionCommon<IsSync, boolean, ChunkForEncoding<Encoding>>;
+  /**
+	How to setup the subprocess' [standard output](https://en.wikipedia.org/wiki/Standard_streams#Standard_input_(stdin)). This can be `'pipe'`, `'overlapped'`, `'ignore`, `'inherit'`, a file descriptor integer, a Node.js `Writable` stream, a web `WritableStream`, a `{ file: 'path' }` object, a file URL, a generator function, a `Duplex` or a web `TransformStream`.
 
-		@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 can be an array of values such as `['inherit', 'pipe']` or `[fileUrl, 'pipe']`.
 
-		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;
-    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>>;
-}
-declare const execa: {
+	@default 'pipe'
+	*/
+  readonly stdout?: StdoutStderrOptionCommon<IsSync, boolean, ChunkForEncoding<Encoding>>;
+  /**
+	How to setup the subprocess' [standard error](https://en.wikipedia.org/wiki/Standard_streams#Standard_input_(stdin)). This can be `'pipe'`, `'overlapped'`, `'ignore`, `'inherit'`, a file descriptor integer, a Node.js `Writable` stream, a web `WritableStream`, a `{ file: 'path' }` object, a file URL, a generator function, a `Duplex` or a web `TransformStream`.
+
+	This can be an array of values such as `['inherit', 'pipe']` or `[fileUrl, 'pipe']`.
+
+	@default 'pipe'
+	*/
+  readonly stderr?: StdoutStderrOptionCommon<IsSync, boolean, ChunkForEncoding<Encoding>>;
   /**
-	Execute a file.
+	Like the `stdin`, `stdout` and `stderr` options but for all [file descriptors](https://en.wikipedia.org/wiki/File_descriptor) at once. For example, `{stdio: ['ignore', 'pipe', 'pipe']}` is the same as `{stdin: 'ignore', stdout: 'pipe', stderr: 'pipe'}`.
 
-	Think of this as a mix of `child_process.execFile` and `child_process.spawn`.
+	A single string can be used as a shortcut.
 
-	@param file - The program/script to execute.
-	@param arguments - Arguments to pass to `file` on execution.
-	@returns A [`child_process` instance](https://nodejs.org/api/child_process.html#child_process_class_childprocess), which is enhanced to also be a `Promise` for a result `Object` with `stdout` and `stderr` properties.
+	The array can have more than 3 items, to create additional file descriptors beyond `stdin`/`stdout`/`stderr`.
 
-	@example
-	```
-	import execa = require('execa');
+	@default 'pipe'
+	*/
+  readonly stdio?: StdioOptionsProperty<IsSync, ChunkForEncoding<Encoding>>;
+  /**
+	Add a `subprocess.all` stream and a `result.all` property. They contain the combined/interleaved output of the subprocess' `stdout` and `stderr`.
 
-	(async () => {
-		const {stdout} = await execa('echo', ['unicorns']);
-		console.log(stdout);
-		//=> 'unicorns'
+	@default false
+	*/
+  readonly all?: boolean;
+  /**
+	If the subprocess outputs text, specifies its character encoding, either [`'utf8'`](https://en.wikipedia.org/wiki/UTF-8) or [`'utf16le'`](https://en.wikipedia.org/wiki/UTF-16).
 
-		// Cancelling a spawned process
+	If it outputs binary data instead, this should be either:
+	- `'buffer'`: returns the binary output as an `Uint8Array`.
+	- [`'hex'`](https://en.wikipedia.org/wiki/Hexadecimal), [`'base64'`](https://en.wikipedia.org/wiki/Base64), [`'base64url'`](https://en.wikipedia.org/wiki/Base64#RFC_4648), [`'latin1'`](https://nodejs.org/api/buffer.html#buffers-and-character-encodings) or [`'ascii'`](https://nodejs.org/api/buffer.html#buffers-and-character-encodings): encodes the binary output as a string.
 
-		const subprocess = execa('node');
+	The output is available with `result.stdout`, `result.stderr` and `result.stdio`.
 
-		setTimeout(() => {
-			subprocess.cancel()
-		}, 1000);
+	@default 'utf8'
+	*/
+  readonly encoding?: Encoding;
+  /**
+	Set `result.stdout`, `result.stderr`, `result.all` and `result.stdio` as arrays of strings, splitting the subprocess' output into lines.
 
-		try {
-			await subprocess;
-		} catch (error) {
-			console.log(subprocess.killed); // true
-			console.log(error.isCanceled); // true
-		}
-	})();
+	This cannot be used if the `encoding` option is binary.
 
-	// Pipe the child process stdout to the current stdout
-	execa('echo', ['unicorns']).stdout.pipe(process.stdout);
-	```
+	By default, this applies to both `stdout` and `stderr`, but different values can also be passed.
+
+	@default false
+	*/
+  readonly lines?: FdGenericOption<boolean>;
+  /**
+	Strip the final [newline character](https://en.wikipedia.org/wiki/Newline) from the output.
+
+	If the `lines` option is true, this applies to each output line instead.
+
+	By default, this applies to both `stdout` and `stderr`, but different values can also be passed.
+
+	@default true
+	*/
+  readonly stripFinalNewline?: FdGenericOption<boolean>;
+  /**
+	Largest amount of data allowed on `stdout`, `stderr` and `stdio`.
+
+	By default, this applies to both `stdout` and `stderr`, but different values can also be passed.
+
+	When reached, `error.isMaxBuffer` becomes `true`.
+
+	@default 100_000_000
+	*/
+  readonly maxBuffer?: FdGenericOption<number>;
+  /**
+	When `buffer` is `false`, the `result.stdout`, `result.stderr`, `result.all` and `result.stdio` properties are not set.
+
+	By default, this applies to both `stdout` and `stderr`, but different values can also be passed.
+
+	@default true
+	*/
+  readonly buffer?: FdGenericOption<boolean>;
+  /**
+	Enables exchanging messages with the subprocess using `subprocess.sendMessage(message)`, `subprocess.getOneMessage()` and `subprocess.getEachMessage()`.
+
+	The subprocess must be a Node.js file.
+
+	@default `true` if the `node`, `ipcInput` or `gracefulCancel` option is set, `false` otherwise
+	*/
+  readonly ipc?: Unless<IsSync, boolean>;
+  /**
+	Specify the kind of serialization used for sending messages between subprocesses when using the `ipc` option.
+
+	@default 'advanced'
+	*/
+  readonly serialization?: Unless<IsSync, 'json' | 'advanced'>;
+  /**
+	Sends an IPC message when the subprocess starts.
+
+	The subprocess must be a Node.js file. The value's type depends on the `serialization` option.
 	*/
-  (file: string, arguments?: readonly string[], options?: execa.Options): execa.ExecaChildProcess;
-  (file: string, arguments?: readonly string[], options?: execa.Options<null>): execa.ExecaChildProcess<Buffer>;
-  (file: string, options?: execa.Options): execa.ExecaChildProcess;
-  (file: string, options?: execa.Options<null>): execa.ExecaChildProcess<Buffer>;
+  readonly ipcInput?: Unless<IsSync, Message>;
   /**
-	Execute a file synchronously.
+	If `verbose` is `'short'`, prints the command on [`stderr`](https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)): its file, arguments, duration and (if it failed) error message.
+
+	If `verbose` is `'full'` or a function, the command's [`stdout`](https://en.wikipedia.org/wiki/Standard_streams#Standard_output_(stdout)), `stderr` and IPC messages are also printed.
+
+	A function can be passed to customize logging.
+
+	By default, this applies to both `stdout` and `stderr`, but different values can also be passed.
 
-	This method throws an `Error` if the command fails.
+	@default 'none'
+	*/
+  readonly verbose?: VerboseOption;
+  /**
+	Setting this to `false` resolves the result's promise with the error instead of rejecting it.
 
-	@param file - The program/script to execute.
-	@param arguments - Arguments to pass to `file` on execution.
-	@returns A result `Object` with `stdout` and `stderr` properties.
+	@default true
 	*/
-  sync(file: string, arguments?: readonly string[], options?: execa.SyncOptions): execa.ExecaSyncReturnValue;
-  sync(file: string, arguments?: readonly string[], options?: execa.SyncOptions<null>): execa.ExecaSyncReturnValue<Buffer>;
-  sync(file: string, options?: execa.SyncOptions): execa.ExecaSyncReturnValue;
-  sync(file: string, options?: execa.SyncOptions<null>): execa.ExecaSyncReturnValue<Buffer>;
+  readonly reject?: boolean;
   /**
-	Same as `execa()` except both file and arguments are specified in a single `command` string. For example, `execa('echo', ['unicorns'])` is the same as `execa.command('echo unicorns')`.
+	If `timeout` is greater than `0`, the subprocess will be terminated if it runs for longer than that amount of milliseconds.
 
-	If the file or an argument contains spaces, they must be escaped with backslashes. This matters especially if `command` is not a constant but a variable, for example with `__dirname` or `process.cwd()`. Except for spaces, no escaping/quoting is needed.
+	On timeout, `error.timedOut` becomes `true`.
 
-	The `shell` option must be used if the `command` uses shell-specific features (for example, `&&` or `||`), as opposed to being a simple `file` followed by its `arguments`.
+	@default 0
+	*/
+  readonly timeout?: number;
+  /**
+	When the `cancelSignal` is [aborted](https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort), terminate the subprocess using a `SIGTERM` signal.
 
-	@param command - The program/script to execute and its arguments.
-	@returns A [`child_process` instance](https://nodejs.org/api/child_process.html#child_process_class_childprocess), which is enhanced to also be a `Promise` for a result `Object` with `stdout` and `stderr` properties.
+	When aborted, `error.isCanceled` becomes `true`.
 
 	@example
 	```
-	import execa = require('execa');
+	import {execaNode} from 'execa';
 
-	(async () => {
-		const {stdout} = await execa.command('echo unicorns');
-		console.log(stdout);
-		//=> 'unicorns'
-	})();
+	const controller = new AbortController();
+	const cancelSignal = controller.signal;
+
+	setTimeout(() => {
+		controller.abort();
+	}, 5000);
+
+	try {
+		await execaNode({cancelSignal})`build.js`;
+	} catch (error) {
+		if (error.isCanceled) {
+			console.error('Canceled by cancelSignal.');
+		}
+
+		throw error;
+	}
 	```
 	*/
-  command(command: string, options?: execa.Options): execa.ExecaChildProcess;
-  command(command: string, options?: execa.Options<null>): execa.ExecaChildProcess<Buffer>;
+  readonly cancelSignal?: Unless<IsSync, AbortSignal>;
+  /**
+	When the `cancelSignal` option is [aborted](https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort), do not send any `SIGTERM`. Instead, abort the [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) returned by `getCancelSignal()`. The subprocess should use it to terminate gracefully.
+
+	The subprocess must be a Node.js file.
+
+	When aborted, `error.isGracefullyCanceled` becomes `true`.
+
+	@default false
+	*/
+  readonly gracefulCancel?: Unless<IsSync, boolean>;
+  /**
+	If the subprocess is terminated but does not exit, forcefully exit it by sending [`SIGKILL`](https://en.wikipedia.org/wiki/Signal_(IPC)#SIGKILL).
+
+	When this happens, `error.isForcefullyTerminated` becomes `true`.
+
+	@default 5000
+	*/
+  readonly forceKillAfterDelay?: Unless<IsSync, number | boolean>;
+  /**
+	Default [signal](https://en.wikipedia.org/wiki/Signal_(IPC)) used to terminate the subprocess.
+
+	This can be either a name (like `'SIGTERM'`) or a number (like `9`).
+
+	@default 'SIGTERM'
+	*/
+  readonly killSignal?: keyof SignalConstants | number;
+  /**
+	Run the subprocess independently from the current process.
+
+	@default false
+	*/
+  readonly detached?: Unless<IsSync, boolean>;
+  /**
+	Kill the subprocess when the current process exits.
+
+	@default true
+	*/
+  readonly cleanup?: Unless<IsSync, boolean>;
+  /**
+	When the subprocess is terminated by Execa, also terminate all of its descendant processes, instead of only the subprocess itself.
+
+	This is useful when the subprocess spawns its own processes, such as when using the `shell` option.
+
+	On Unix, this spawns the subprocess in its own [process group](https://en.wikipedia.org/wiki/Process_group). On Windows, this uses [`taskkill`](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/taskkill).
+
+	This is best-effort: descendant processes that create their own process group or session are not terminated.
+
+	@default false
+	*/
+  readonly killDescendants?: Unless<IsSync, boolean>;
+  /**
+	Sets the [user identifier](https://en.wikipedia.org/wiki/User_identifier) of the subprocess.
+
+	@default current user identifier
+	*/
+  readonly uid?: number;
+  /**
+	Sets the [group identifier](https://en.wikipedia.org/wiki/Group_identifier) of the subprocess.
+
+	@default current group identifier
+	*/
+  readonly gid?: number;
+  /**
+	Value of [`argv[0]`](https://nodejs.org/api/process.html#processargv0) sent to the subprocess.
+
+	@default file being executed
+	*/
+  readonly argv0?: string;
+  /**
+	On Windows, do not create a new console window.
+
+	@default true
+	*/
+  readonly windowsHide?: boolean;
+  /**
+	If `false`, escapes the command arguments on Windows.
+
+	@default `true` if the `shell` option is `true`, `false` otherwise
+	*/
+  readonly windowsVerbatimArguments?: boolean;
+};
+/**
+Subprocess options.
+
+Some options are related to the subprocess output: `verbose`, `lines`, `stripFinalNewline`, `buffer`, `maxBuffer`. By default, those options apply to all file descriptors (`stdout`, `stderr`, etc.). A plain object can be passed instead to apply them to only `stdout`, `stderr`, `all` (both stdout and stderr), `ipc`, `fd3`, etc.
+
+@example
+
+```
+// Same value for stdout and stderr
+await execa({verbose: 'full'})`npm run build`;
+
+// Different values for stdout and stderr
+await execa({verbose: {stdout: 'none', stderr: 'full'}})`npm run build`;
+```
+*/
+type TextOptions<IsSync extends boolean> = CommonOptions<IsSync, TextEncodingOption | undefined>;
+type BinaryOptions<IsSync extends boolean> = Omit<CommonOptions<IsSync, BinaryEncodingOption>, 'encoding'> & {
+  readonly encoding: BinaryEncodingOption;
+};
+type Options$1 = TextOptions<false> | BinaryOptions<false>;
+/**
+Subprocess options, with synchronous methods.
+
+Some options are related to the subprocess output: `verbose`, `lines`, `stripFinalNewline`, `buffer`, `maxBuffer`. By default, those options apply to all file descriptors (`stdout`, `stderr`, etc.). A plain object can be passed instead to apply them to only `stdout`, `stderr`, `all` (both stdout and stderr), `ipc`, `fd3`, etc.
+
+@example
+
+```
+// Same value for stdout and stderr
+execaSync({verbose: 'full'})`npm run build`;
+
+// Different values for stdout and stderr
+execaSync({verbose: {stdout: 'none', stderr: 'full'}})`npm run build`;
+```
+*/
+type SyncOptions = TextOptions<true> | BinaryOptions<true>;
+type StricterOptions<WideOptions extends CommonOptions, StrictOptions extends CommonOptions> = WideOptions extends StrictOptions ? WideOptions : StrictOptions;
+//#endregion
+//#region ../../node_modules/execa/types/methods/template.d.ts
+type TemplateExpressionItem = string | number | Result | SyncResult;
+/**
+Value allowed inside `${...}` when using the template string syntax.
+*/
+type TemplateExpression = TemplateExpressionItem | readonly TemplateExpressionItem[];
+// `...${...}...` template syntax
+type TemplateString = readonly [TemplateStringsArray, ...readonly TemplateExpression[]];
+//#endregion
+//#region ../../node_modules/execa/types/pipe.d.ts
+// `subprocess.pipe()` options
+type PipeOptions = {
+  /**
+	Which stream to pipe from the source subprocess. A [file descriptor](https://en.wikipedia.org/wiki/File_descriptor) like `"fd3"` can also be passed.
+
+	`"all"` pipes both `stdout` and `stderr`. This requires the `all` option to be `true`.
+	*/
+  readonly from?: FromOption;
+  /**
+	Which stream to pipe to the destination subprocess. A [file descriptor](https://en.wikipedia.org/wiki/File_descriptor) like `"fd3"` can also be passed.
+	*/
+  readonly to?: ToOption;
+  /**
+	Unpipe the subprocess when the signal aborts.
+	*/
+  readonly unpipeSignal?: AbortSignal;
+};
+// Methods forwarded from the destination subprocess to the return value of `subprocess.pipe()`, so its output can be iterated, converted to a stream, or used for IPC.
+type PipeResultMethods<OptionsType extends Options$1> = SubprocessResultMethods<OptionsType> & IpcMethods<HasIpc<OptionsType>, OptionsType['serialization']>;
+// Same as `PipeResultMethods`, but when the destination is another `execa()` call, so its own option types are kept.
+// The base `Options` is only used to compute the property names, which do not depend on the specific options.
+type PipeResultMethodsFrom<Destination extends ResultPromise> = Pick<Destination, keyof PipeResultMethods<Options$1>>;
+// `subprocess.pipe()`
+type PipableSubprocess = {
+  /**
+	[Pipe](https://nodejs.org/api/stream.html#readablepipedestination-options) the subprocess' `stdout` to a second Execa subprocess' `stdin`. This resolves with that second subprocess' result. If either subprocess is rejected, this is rejected with that subprocess' error instead.
+
+	This follows the same syntax as `execa(file, arguments?, options?)` except both regular options and pipe-specific options can be specified.
+
+	Like a subprocess, the return value can be [iterated](https://github.com/sindresorhus/execa/blob/main/docs/lines.md#progressive-splitting), [converted to a stream](https://github.com/sindresorhus/execa/blob/main/docs/streams.md#converting-a-subprocess-to-a-stream), or used for [IPC](https://github.com/sindresorhus/execa/blob/main/docs/ipc.md) with the destination subprocess.
+	*/
+  pipe<OptionsType extends Options$1 & PipeOptions = {}>(file: string | URL, arguments?: readonly string[], options?: OptionsType): Promise<Result<OptionsType>> & PipableSubprocess & PipeResultMethods<OptionsType>;
+  pipe<OptionsType extends Options$1 & PipeOptions = {}>(file: string | URL, options?: OptionsType): Promise<Result<OptionsType>> & PipableSubprocess & PipeResultMethods<OptionsType>;
+  /**
+	Like `subprocess.pipe(file, arguments?, options?)` but using a `command` template string instead. This follows the same syntax as `$`.
+	*/
+  pipe(templates: TemplateStringsArray, ...expressions: readonly TemplateExpression[]): Promise<Result<{}>> & PipableSubprocess & PipeResultMethods<{}>;
+  pipe<OptionsType extends Options$1 & PipeOptions = {}>(options: OptionsType): (templates: TemplateStringsArray, ...expressions: readonly TemplateExpression[]) => Promise<Result<OptionsType>> & PipableSubprocess & PipeResultMethods<OptionsType>;
+  /**
+	Like `subprocess.pipe(file, arguments?, options?)` but using the return value of another `execa()` call instead.
+	*/
+  pipe<Destination extends ResultPromise>(destination: Destination, options?: PipeOptions): Promise<Awaited<Destination>> & PipableSubprocess & PipeResultMethodsFrom<Destination>;
+};
+//#endregion
+//#region ../../node_modules/execa/types/convert.d.ts
+// `subprocess.readable|duplex|iterable()` options
+type ReadableOptions = {
+  /**
+	Which stream to read from the subprocess. A [file descriptor](https://en.wikipedia.org/wiki/File_descriptor) like `"fd3"` can also be passed.
+
+	`"all"` reads both `stdout` and `stderr`. This requires the `all` option to be `true`.
+
+	@default 'stdout'
+	*/
+  readonly from?: FromOption;
+  /**
+	If `false`, iterates over lines. Each line is a string.
+
+	If `true`, iterates over arbitrary chunks of data. Each line is an [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) (with `subprocess.iterable()`) or a [`Buffer`](https://nodejs.org/api/buffer.html#class-buffer) (with `subprocess.readable()`/`subprocess.duplex()`).
+
+	This is always `true` when the `encoding` option is binary.
+
+	@default `false` with `subprocess.iterable()`, `true` otherwise
+	*/
+  readonly binary?: boolean;
+  /**
+	If both this option and the `binary` option is `false`, [newlines](https://en.wikipedia.org/wiki/Newline) are stripped from each line.
+
+	@default `false` with `subprocess.iterable()`, `true` otherwise
+	*/
+  readonly preserveNewlines?: boolean;
+};
+// `subprocess.writable|duplex()` options
+type WritableOptions = {
   /**
-	Same as `execa.command()` but synchronous.
+	Which stream to write to the subprocess. A [file descriptor](https://en.wikipedia.org/wiki/File_descriptor) like `"fd3"` can also be passed.
 
-	@param command - The program/script to execute and its arguments.
-	@returns A result `Object` with `stdout` and `stderr` properties.
+	@default 'stdin'
 	*/
-  commandSync(command: string, options?: execa.SyncOptions): execa.ExecaSyncReturnValue;
-  commandSync(command: string, options?: execa.SyncOptions<null>): execa.ExecaSyncReturnValue<Buffer>;
+  readonly to?: ToOption;
+};
+// `subprocess.duplex()` options
+type DuplexOptions = ReadableOptions & WritableOptions;
+// `subprocess.iterable()` return value
+type SubprocessAsyncIterable<BinaryOption extends boolean | undefined, EncodingOption extends Options$1['encoding']> = AsyncIterableIterator<EncodingOption extends BinaryEncodingOption ? Uint8Array : BinaryOption extends true ? Uint8Array : string>;
+//#endregion
+//#region ../../node_modules/execa/types/subprocess/stdout.d.ts
+// `subprocess.stdin|stdout|stderr|stdio`
+type SubprocessStdioStream<FdNumber extends string, OptionsType extends Options$1> = SubprocessStream<FdNumber, IgnoresSubprocessOutput<FdNumber, OptionsType>, OptionsType>;
+type SubprocessStream<FdNumber extends string, StreamResultIgnored, OptionsType extends Options$1> = StreamResultIgnored extends true ? null : InputOutputStream<IsInputFd<FdNumber, OptionsType>>;
+type InputOutputStream<IsInput extends boolean> = IsInput extends true ? Writable : Readable;
+//#endregion
+//#region ../../node_modules/execa/types/subprocess/stdio.d.ts
+// `subprocess.stdio`
+type SubprocessStdioArray<OptionsType extends Options$1> = MapStdioStreams<StdioOptionNormalizedArray<OptionsType>, OptionsType>;
+// We cannot use mapped types because it must be compatible with Node.js `ChildProcess["stdio"]` which uses a tuple with exactly 5 items
+type MapStdioStreams<StdioOptionsArrayType, OptionsType extends Options$1> = [SubprocessStdioStream<'0', OptionsType>, SubprocessStdioStream<'1', OptionsType>, SubprocessStdioStream<'2', OptionsType>, '3' extends keyof StdioOptionsArrayType ? SubprocessStdioStream<'3', OptionsType> : never, '4' extends keyof StdioOptionsArrayType ? SubprocessStdioStream<'4', OptionsType> : never];
+//#endregion
+//#region ../../node_modules/execa/types/subprocess/all.d.ts
+// `subprocess.all`
+type SubprocessAll<OptionsType extends Options$1> = AllStream<AllIgnored<OptionsType['all'], OptionsType>>;
+type AllStream<IsIgnored> = IsIgnored extends true ? undefined : Readable;
+type AllIgnored<AllOption, OptionsType extends Options$1> = AllOption extends true ? IgnoresSubprocessOutput<'1', OptionsType> extends true ? IgnoresSubprocessOutput<'2', OptionsType> : false : true;
+//#endregion
+//#region ../../node_modules/execa/types/subprocess/subprocess.d.ts
+// Read-side iteration, stream conversion and `all` methods.
+// These are shared between a subprocess and the return value of `subprocess.pipe()`, which forwards them from its destination subprocess.
+// `writable()`, `duplex()`, `writableStream()` and `transformStream()` are not included: they write to `stdin`, which the pipe already feeds from its source.
+type SubprocessResultMethods<OptionsType extends Options$1 = Options$1> = {
   /**
-	Execute a Node.js script as a child process.
+	Stream combining/interleaving `subprocess.stdout` and `subprocess.stderr`.
 
-	Same as `execa('node', [scriptPath, ...arguments], options)` except (like [`child_process#fork()`](https://nodejs.org/api/child_process.html#child_process_child_process_fork_modulepath_args_options)):
-		- the current Node version and options are used. This can be overridden using the `nodePath` and `nodeArguments` options.
-		- the `shell` option cannot be used
-		- an extra channel [`ipc`](https://nodejs.org/api/child_process.html#child_process_options_stdio) is passed to [`stdio`](#stdio)
+	This requires the `all` option to be `true`.
 
-	@param scriptPath - Node.js script to execute.
-	@param arguments - Arguments to pass to `scriptPath` on execution.
-	@returns A [`child_process` instance](https://nodejs.org/api/child_process.html#child_process_class_childprocess), which is enhanced to also be a `Promise` for a result `Object` with `stdout` and `stderr` properties.
+	This is `undefined` if `stdout` and `stderr` options are set to `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
 	*/
-  node(scriptPath: string, arguments?: readonly string[], options?: execa.NodeOptions): execa.ExecaChildProcess;
-  node(scriptPath: string, arguments?: readonly string[], options?: execa.Options<null>): execa.ExecaChildProcess<Buffer>;
-  node(scriptPath: string, options?: execa.Options): execa.ExecaChildProcess;
-  node(scriptPath: string, options?: execa.Options<null>): execa.ExecaChildProcess<Buffer>;
+  all: SubprocessAll<OptionsType>;
+  /**
+	Subprocesses are [async iterables](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/asyncIterator). They iterate over each output line.
+	*/
+  [Symbol.asyncIterator](): SubprocessAsyncIterable<undefined, OptionsType['encoding']>;
+  /**
+	Same as `subprocess[Symbol.asyncIterator]` except options can be provided.
+	*/
+  iterable<IterableOptions extends ReadableOptions = {}>(readableOptions?: IterableOptions): SubprocessAsyncIterable<IterableOptions['binary'], OptionsType['encoding']>;
+  /**
+	Converts the subprocess to a readable stream.
+	*/
+  readable(readableOptions?: ReadableOptions): Readable;
+  /**
+	Converts the subprocess to a readable [web stream](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream).
+	*/
+  readableStream(readableOptions?: ReadableOptions): ReadableStream;
 };
+type ExecaCustomSubprocess<OptionsType extends Options$1> = IpcMethods<HasIpc<OptionsType>, OptionsType['serialization']> & PipableSubprocess & SubprocessResultMethods<OptionsType> & {
+  /**
+		Process identifier ([PID](https://en.wikipedia.org/wiki/Process_identifier)).
+
+		This is `undefined` if the subprocess failed to spawn.
+		*/
+  pid?: number;
+  /**
+		The subprocess [`stdin`](https://en.wikipedia.org/wiki/Standard_streams#Standard_input_(stdin)) as a stream.
+
+		This is `null` if the `stdin` option is set to `'inherit'`, `'ignore'`, `Readable` or `integer`.
+		*/
+  stdin: SubprocessStdioStream<'0', OptionsType>;
+  /**
+		The subprocess [`stdout`](https://en.wikipedia.org/wiki/Standard_streams#Standard_output_(stdout)) as a stream.
+
+		This is `null` if the `stdout` option is set to `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
+		*/
+  stdout: SubprocessStdioStream<'1', OptionsType>;
+  /**
+		The subprocess [`stderr`](https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)) as a stream.
+
+		This is `null` if the `stderr` option is set to `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
+		*/
+  stderr: SubprocessStdioStream<'2', OptionsType>;
+  /**
+		The subprocess `stdin`, `stdout`, `stderr` and other files descriptors as an array of streams.
+
+		Each array item is `null` if the corresponding `stdin`, `stdout`, `stderr` or `stdio` option is set to `'inherit'`, `'ignore'`, `Stream` or `integer`, or if the `buffer` option is `false`.
+		*/
+  stdio: SubprocessStdioArray<OptionsType>;
+  /**
+		Sends a [signal](https://nodejs.org/api/os.html#signal-constants) to the subprocess. The default signal is the `killSignal` option. `killSignal` defaults to `SIGTERM`, which terminates the subprocess.
+
+		This returns `false` when the signal could not be sent, for example when the subprocess has already exited.
+
+		When an error is passed as argument, it is set to the subprocess' `error.cause`. The subprocess is then terminated with the default signal. This does not emit the [`error` event](https://nodejs.org/api/child_process.html#event-error).
+
+		[More info.](https://nodejs.org/api/child_process.html#subprocesskillsignal)
+		*/
+  kill(signal?: keyof SignalConstants | number, error?: Error): boolean;
+  kill(error?: Error): boolean;
+  /**
+		Converts the subprocess to a writable stream.
+		*/
+  writable(writableOptions?: WritableOptions): Writable;
+  /**
+		Converts the subprocess to a duplex stream.
+		*/
+  duplex(duplexOptions?: DuplexOptions): Duplex;
+  /**
+		Converts the subprocess to a writable [web stream](https://developer.mozilla.org/en-US/docs/Web/API/WritableStream).
+		*/
+  writableStream(writableOptions?: WritableOptions): WritableStream;
+  /**
+		Converts the subprocess to a [`{readable, writable}`](https://developer.mozilla.org/en-US/docs/Web/API/TransformStream) pair of web streams.
+		*/
+  transformStream(duplexOptions?: DuplexOptions): ReadableWritablePair;
+  /**
+		Underlying Node.js [`ChildProcess`](https://nodejs.org/api/child_process.html#class-childprocess) instance.
+
+		This is an escape hatch for Node.js-specific APIs not documented by Execa, such as `.on()`, `.send()`, `.disconnect()`, `.ref()` or `.unref()`.
+		*/
+  nodeChildProcess: ChildProcess;
+};
+/**
+Subprocess with Execa-specific methods and properties. It is also a `Promise` either resolving with its successful `result`, or rejecting with its `error`.
+*/
+type Subprocess<OptionsType extends Options$1 = Options$1> = ExecaCustomSubprocess<OptionsType> & Promise<Result<OptionsType>>;
+/**
+The return value of all asynchronous methods is both:
+- the subprocess with Execa-specific methods and properties.
+- a `Promise` either resolving with its successful `result`, or rejecting with its `error`.
+*/
+type ResultPromise<OptionsType extends Options$1 = Options$1> = Subprocess<OptionsType>;
+//#endregion
+//#region ../../node_modules/execa/types/methods/main-async.d.ts
+/**
+Executes a command using `file ...arguments`.
+
+When `command` is a template string, it includes both the `file` and its `arguments`.
+
+`execa(options)` can be used to return a new instance of this method but with different default `options`. Consecutive calls are merged to previous ones.
+
+@param file - The program/script to execute, as a string or file URL
+@param arguments - Arguments to pass to `file` on execution.
+@returns A `ResultPromise` that is both:
+- the subprocess.
+- a `Promise` either resolving with its successful `result`, or rejecting with its `error`.
+@throws `ExecaError`
+
+@example <caption>Simple syntax</caption>
+
+```
+import {execa} from 'execa';
+
+const {stdout} = await execa`npm run build`;
+// Print command's output
+console.log(stdout);
+```
+
+@example <caption>Script</caption>
+
+```
+import {$} from 'execa';
+
+const {stdout: name} = await $`cat package.json`.pipe`grep name`;
+console.log(name);
+
+const branch = await $`git branch --show-current`;
+await $`dep deploy --branch=${branch}`;
+
+await Promise.all([
+	$`sleep 1`,
+	$`sleep 2`,
+	$`sleep 3`,
+]);
+
+const directoryName = 'foo bar';
+await $`mkdir /tmp/${directoryName}`;
+```
+
+@example <caption>Local binaries</caption>
+
+```
+$ npm install -D eslint
+```
+
+```
+await execa({preferLocal: true})`eslint`;
+```
+
+@example <caption>Pipe multiple subprocesses</caption>
+
+```
+const {stdout, pipedFrom} = await execa`npm run build`
+	.pipe`sort`
+	.pipe`head -n 2`;
+
+// Output of `npm run build | sort | head -n 2`
+console.log(stdout);
+// Output of `npm run build | sort`
+console.log(pipedFrom[0].stdout);
+// Output of `npm run build`
+console.log(pipedFrom[0].pipedFrom[0].stdout);
+```
+
+@example <caption>Interleaved output</caption>
+
+```
+const {all} = await execa({all: true})`npm run build`;
+// stdout + stderr, interleaved
+console.log(all);
+```
+
+@example <caption>Programmatic + terminal output</caption>
+
+```
+const {stdout} = await execa({stdout: ['pipe', 'inherit']})`npm run build`;
+// stdout is also printed to the terminal
+console.log(stdout);
+```
+
+@example <caption>Simple input</caption>
+
+```
+const getInputString = () => { /* ... *\/ };
+const {stdout} = await execa({input: getInputString()})`sort`;
+console.log(stdout);
+```
+
+@example <caption>File input</caption>
+
+```
+// Similar to: npm run build < input.txt
+await execa({stdin: {file: 'input.txt'}})`npm run build`;
+```
+
+@example <caption>File output</caption>
+
+```
+// Similar to: npm run build > output.txt
+await execa({stdout: {file: 'output.txt'}})`npm run build`;
+```
+
+@example <caption>Split into text lines</caption>
+
+```
+const {stdout} = await execa({lines: true})`npm run build`;
+// Print first 10 lines
+console.log(stdout.slice(0, 10).join('\n'));
+```
+
+@example <caption>Iterate over text lines</caption>
+
+```
+for await (const line of execa`npm run build`) {
+	if (line.includes('WARN')) {
+		console.warn(line);
+	}
+}
+```
+
+@example <caption>Transform/filter output</caption>
+
+```
+let count = 0;
+
+// Filter out secret lines, then prepend the line number
+const transform = function * (line) {
+	if (!line.includes('secret')) {
+		yield `[${count++}] ${line}`;
+	}
+};
+
+await execa({stdout: transform})`npm run build`;
+```
+
+@example <caption>Web streams</caption>
+
+```
+const response = await fetch('https://example.com');
+await execa({stdin: response.body})`sort`;
+```
+
+@example <caption>Convert to Duplex stream</caption>
+
+```
+import {execa} from 'execa';
+import {pipeline} from 'node:stream/promises';
+import {createReadStream, createWriteStream} from 'node:fs';
+
+await pipeline(
+	createReadStream('./input.txt'),
+	execa`node ./transform.js`.duplex(),
+	createWriteStream('./output.txt'),
+);
+```
+
+@example <caption>Exchange messages</caption>
+
+```
+// parent.js
+import {execaNode} from 'execa';
+
+const subprocess = execaNode`child.js`;
+await subprocess.sendMessage('Hello from parent');
+const message = await subprocess.getOneMessage();
+console.log(message); // 'Hello from child'
+```
+
+```
+// child.js
+import {getOneMessage, sendMessage} from 'execa';
+
+const message = await getOneMessage(); // 'Hello from parent'
+const newMessage = message.replace('parent', 'child'); // 'Hello from child'
+await sendMessage(newMessage);
+```
+
+@example <caption>Any input type</caption>
+
+```
+// main.js
+import {execaNode} from 'execa';
+
+const ipcInput = [
+	{task: 'lint', ignore: /test\.js/},
+	{task: 'copy', files: new Set(['main.js', 'index.js']),
+}];
+await execaNode({ipcInput})`build.js`;
+```
+
+```
+// build.js
+import {getOneMessage} from 'execa';
+
+const ipcInput = await getOneMessage();
+```
+
+@example <caption>Any output type</caption>
+
+```
+// main.js
+import {execaNode} from 'execa';
+
+const {ipcOutput} = await execaNode`build.js`;
+console.log(ipcOutput[0]); // {kind: 'start', timestamp: date}
+console.log(ipcOutput[1]); // {kind: 'stop', timestamp: date}
+```
+
+```
+// build.js
+import {sendMessage} from 'execa';
+
+const runBuild = () => { /* ... *\/ };
+
+await sendMessage({kind: 'start', timestamp: new Date()});
+await runBuild();
+await sendMessage({kind: 'stop', timestamp: new Date()});
+```
+
+@example <caption>Graceful termination</caption>
+
+```
+// main.js
+import {execaNode} from 'execa';
+
+const controller = new AbortController();
+setTimeout(() => {
+	controller.abort();
+}, 5000);
+
+await execaNode({
+	cancelSignal: controller.signal,
+	gracefulCancel: true,
+})`build.js`;
+```
+
+```
+// build.js
+import {getCancelSignal} from 'execa';
+
+const cancelSignal = await getCancelSignal();
+const url = 'https://example.com/build/info';
+const response = await fetch(url, {signal: cancelSignal});
+```
+
+@example <caption>Detailed error</caption>
+
+```
+import {execa, ExecaError} from 'execa';
+
+try {
+	await execa`unknown command`;
+} catch (error) {
+	if (error instanceof ExecaError) {
+		console.log(error);
+	}
+	/*
+	ExecaError: Command failed with ENOENT: unknown command
+	spawn unknown ENOENT
+			at ...
+			at ... {
+		shortMessage: 'Command failed with ENOENT: unknown command\nspawn unknown ENOENT',
+		originalMessage: 'spawn unknown ENOENT',
+		command: 'unknown command',
+		escapedCommand: 'unknown command',
+		cwd: '/path/to/cwd',
+		durationMs: 28.217566,
+		failed: true,
+		timedOut: false,
+		isCanceled: false,
+		isTerminated: false,
+		isMaxBuffer: false,
+		code: 'ENOENT',
+		stdout: '',
+		stderr: '',
+		stdio: [undefined, '', ''],
+		pipedFrom: []
+		[cause]: Error: spawn unknown ENOENT
+				at ...
+				at ... {
+			errno: -2,
+			code: 'ENOENT',
+			syscall: 'spawn unknown',
+			path: 'unknown',
+			spawnargs: [ 'command' ]
+		}
+	}
+	*\/
+}
+```
+
+@example <caption>Verbose mode</caption>
+
+```
+await execa`npm run build`;
+await execa`npm run test`;
+```
+
+```
+$ NODE_DEBUG=execa node build.js
+[00:57:44.581] [0] $ npm run build
+[00:57:44.653] [0]   Building application...
+[00:57:44.653] [0]   Done building.
+[00:57:44.658] [0] ✔ (done in 78ms)
+[00:57:44.658] [1] $ npm run test
+[00:57:44.740] [1]   Running tests...
+[00:57:44.740] [1]   Error: the entrypoint is invalid.
+[00:57:44.747] [1] ✘ Command failed with exit code 1: npm run test
+[00:57:44.747] [1] ✘ (done in 89ms)
+```
+
+@example <caption>Custom logging</caption>
+
+```
+import {execa as execa_} from 'execa';
+import {createLogger, transports} from 'winston';
+
+// Log to a file using Winston
+const transport = new transports.File({filename: 'logs.txt'});
+const logger = createLogger({transports: [transport]});
+const LOG_LEVELS = {
+	command: 'info',
+	output: 'verbose',
+	ipc: 'verbose',
+	error: 'error',
+	duration: 'info',
+};
+
+const execa = execa_({
+	verbose(verboseLine, {message, ...verboseObject}) {
+		const level = LOG_LEVELS[verboseObject.type];
+		logger[level](message, verboseObject);
+	},
+});
+
+await execa`npm run build`;
+await execa`npm run test`;
+```
+*/
+declare const execa: ExecaMethod<{}>;
+/**
+`execa()` method either exported by Execa, or bound using `execa(options)`.
+*/
+type ExecaMethod<OptionsType extends Options$1 = Options$1> = ExecaBind<OptionsType> & ExecaTemplate<OptionsType> & ExecaArrayLong<OptionsType> & ExecaArrayShort<OptionsType>;
+// `execa(options)` binding
+type ExecaBind<OptionsType extends Options$1> = <NewOptionsType extends Options$1 = {}>(options: NewOptionsType) => ExecaMethod<OptionsType & NewOptionsType>;
+// `execa`command`` template syntax
+type ExecaTemplate<OptionsType extends Options$1> = (...templateString: TemplateString) => ResultPromise<OptionsType>;
+// `execa('file', ['argument'], {})` array syntax
+type ExecaArrayLong<OptionsType extends Options$1> = <NewOptionsType extends Options$1 = {}>(file: string | URL, arguments?: readonly string[], options?: NewOptionsType) => ResultPromise<OptionsType & NewOptionsType>;
+// `execa('file', {})` array syntax
+type ExecaArrayShort<OptionsType extends Options$1> = <NewOptionsType extends Options$1 = {}>(file: string | URL, options?: NewOptionsType) => ResultPromise<OptionsType & NewOptionsType>;
+//#endregion
+//#region ../../node_modules/execa/types/methods/main-sync.d.ts
+/**
+Same as `execa()` but synchronous.
+
+Returns a subprocess `result` or throws an `error`. The `subprocess` is not returned: its methods and properties are not available.
+
+When `command` is a template string, it includes both the `file` and its `arguments`.
+
+`execaSync(options)` can be used to return a new instance of this method but with different default `options`. Consecutive calls are merged to previous ones.
+
+This method is discouraged as it holds the CPU and lacks multiple features.
+
+@param file - The program/script to execute, as a string or file URL
+@param arguments - Arguments to pass to `file` on execution.
+@returns `SyncResult`
+@throws `ExecaSyncError`
+
+@example
+
+```
+import {execaSync} from 'execa';
+
+const {stdout} = execaSync`npm run build`;
+// Print command's output
+console.log(stdout);
+```
+*/
+declare const execaSync: ExecaSyncMethod<{}>;
+// For the moment, we purposely do not export `ExecaSyncMethod` and `ExecaScriptSyncMethod`.
+// This is because synchronous invocation is discouraged.
+type ExecaSyncMethod<OptionsType extends SyncOptions = SyncOptions> = ExecaSyncBind<OptionsType> & ExecaSyncTemplate<OptionsType> & ExecaSyncArrayLong<OptionsType> & ExecaSyncArrayShort<OptionsType>;
+// `execaSync(options)` binding
+type ExecaSyncBind<OptionsType extends SyncOptions> = <NewOptionsType extends SyncOptions = {}>(options: NewOptionsType) => ExecaSyncMethod<OptionsType & NewOptionsType>;
+// `execaSync`command`` template syntax
+type ExecaSyncTemplate<OptionsType extends SyncOptions> = (...templateString: TemplateString) => SyncResult<OptionsType>;
+// `execaSync('file', ['argument'], {})` array syntax
+type ExecaSyncArrayLong<OptionsType extends SyncOptions> = <NewOptionsType extends SyncOptions = {}>(file: string | URL, arguments?: readonly string[], options?: NewOptionsType) => SyncResult<OptionsType & NewOptionsType>;
+// `execaSync('file', {})` array syntax
+type ExecaSyncArrayShort<OptionsType extends SyncOptions> = <NewOptionsType extends SyncOptions = {}>(file: string | URL, options?: NewOptionsType) => SyncResult<OptionsType & NewOptionsType>;
 //#endregion
 //#region src/common/cli/cli.d.ts
 type RunOptions = Record<string, unknown>;
+type CliSyncResult = ReturnType<typeof execaSync>;
 interface CliResult extends Promise<unknown> {
   toObservable(opt?: RunOptions): Observable<string>;
-  toStream(opt?: RunOptions): execa.ExecaChildProcess<string>;
+  toStream(opt?: RunOptions): ReturnType<typeof execa>;
   cwd(cwd: string): CliResult;
-  sync(opt?: RunOptions): execa.ExecaSyncReturnValue<string>;
+  sync(opt?: RunOptions): CliSyncResult;
   getRaw(opt?: RunOptions): string;
   get(opt?: RunOptions): string;
 }
-type CliSyncResult = execa.ExecaSyncReturnValue<string>;
 declare class Cli {
   cmd: string;
   constructor(cmd: string);
@@ -1958,7 +3154,7 @@ interface ConditionalPluginOptions {
   [key: string]: unknown;
 }
 type Plugin = string | [string, ConditionalPluginOptions];
-interface CmReleaseConfig extends Options$1 {
+interface CmReleaseConfig extends Options {
   verifyConditions?: readonly Plugin[];
   analyzeCommits?: readonly Plugin[];
   verifyRelease?: readonly Plugin[];