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

package/dist/index.d.mts

@@ -0,0 +1,3232 @@
+
+/// <reference path="operators/index.d.ts" />
+/// <reference path="testing/index.d.ts" />
+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 "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>
+/* 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.
+// References:
+// - https://github.com/microsoft/TypeScript/issues/29729
+// - https://github.com/sindresorhus/type-fest/blob/main/source/literal-union.d.ts
+// - https://github.com/sindresorhus/type-fest/blob/main/source/primitive.d.ts
+type LiteralUnion<LiteralType, BaseType extends string | number> = LiteralType | (BaseType & Record<never, never>);
+declare class CommanderError extends Error {
+  code: string;
+  exitCode: number;
+  message: string;
+  nestedError?: string;
+  /**
+   * Constructs the CommanderError class
+   * @param exitCode - suggested exit code which could be used with process.exit
+   * @param code - an id string representing the error
+   * @param message - human-readable description of the error
+   */
+  constructor(exitCode: number, code: string, message: string);
+}
+interface ErrorOptions {
+  // optional parameter for error()
+  /** an id string representing the error */
+  code?: string;
+  /** suggested exit code which could be used with process.exit */
+  exitCode?: number;
+}
+declare class Argument {
+  description: string;
+  required: boolean;
+  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.
+   * The default is that the argument is required, and you can explicitly
+   * indicate this with <> around the name. Put [] around the name for an optional argument.
+   */
+  constructor(arg: string, description?: string);
+  /**
+   * Return argument name.
+   */
+  name(): string;
+  /**
+   * Set the default value, and optionally supply the description to be displayed in the help.
+   */
+  default(value: unknown, description?: string): this;
+  /**
+   * Set the custom handler for processing CLI command arguments into argument values.
+   */
+  argParser<T>(fn: (value: string, previous: T) => T): this;
+  /**
+   * Only allow argument value to be one of choices.
+   */
+  choices(values: readonly string[]): this;
+  /**
+   * Make argument required.
+   */
+  argRequired(): this;
+  /**
+   * Make argument optional.
+   */
+  argOptional(): this;
+}
+declare class Option {
+  flags: string;
+  description: string;
+  required: boolean; // A value must be supplied when the option is specified.
+  optional: boolean; // A value is optional when the option is specified.
+  variadic: boolean;
+  mandatory: boolean; // The option must have a value after parsing, which usually means it must be specified on command line.
+  short?: string;
+  long?: string;
+  negate: boolean;
+  defaultValue?: any;
+  defaultValueDescription?: string;
+  presetArg?: unknown;
+  envVar?: string;
+  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.
+   */
+  default(value: unknown, description?: string): this;
+  /**
+   * Preset to use when option used without option-argument, especially optional but also boolean and negated.
+   * The custom processing (parseArg) is called.
+   *
+   * @example
+   * ```ts
+   * new Option('--color').default('GREYSCALE').preset('RGB');
+   * new Option('--donate [amount]').preset('20').argParser(parseFloat);
+   * ```
+   */
+  preset(arg: unknown): this;
+  /**
+   * Add option name(s) that conflict with this option.
+   * An error will be displayed if conflicting options are found during parsing.
+   *
+   * @example
+   * ```ts
+   * new Option('--rgb').conflicts('cmyk');
+   * new Option('--js').conflicts(['ts', 'jsx']);
+   * ```
+   */
+  conflicts(names: string | string[]): this;
+  /**
+   * Specify implied option values for when this option is set and the implied options are not.
+   *
+   * The custom processing (parseArg) is not called on the implied values.
+   *
+   * @example
+   * program
+   *   .addOption(new Option('--log', 'write logging information to file'))
+   *   .addOption(new Option('--trace', 'log extra details').implies({ log: 'trace.txt' }));
+   */
+  implies(optionValues: OptionValues): this;
+  /**
+   * Set environment variable to check for option value.
+   *
+   * An environment variables is only used if when processed the current option value is
+   * undefined, or the source of the current value is 'default' or 'config' or 'env'.
+   */
+  env(name: string): this;
+  /**
+   * Set the custom handler for processing CLI option arguments into option values.
+   */
+  argParser<T>(fn: (value: string, previous: T) => T): this;
+  /**
+   * Whether the option is mandatory and must have a value after parsing.
+   */
+  makeOptionMandatory(mandatory?: boolean): this;
+  /**
+   * Hide option in help.
+   */
+  hideHelp(hide?: boolean): this;
+  /**
+   * Only allow option value to be one of choices.
+   */
+  choices(values: readonly string[]): this;
+  /**
+   * Return option name.
+   */
+  name(): string;
+  /**
+   * Return option name, in a camelcase format that can be used
+   * as an object attribute key.
+   */
+  attributeName(): string;
+  /**
+   * Set the help group heading.
+   */
+  helpGroup(heading: string): this;
+  /**
+   * Return whether a boolean option.
+   *
+   * Options are one of boolean, negated, required argument, or optional argument.
+   */
+  isBoolean(): boolean;
+}
+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. */
+  subcommandDescription(cmd: Command): string;
+  /** Get the option term to show in the list of options. */
+  optionTerm(option: Option): string;
+  /** Get the option description to show in the list of options. */
+  optionDescription(option: Option): string;
+  /** Get the argument term to show in the list of arguments. */
+  argumentTerm(argument: Argument): string;
+  /** Get the argument description to show in the list of arguments. */
+  argumentDescription(argument: Argument): string;
+  /** Get the command usage to be displayed at the top of the built-in help. */
+  commandUsage(cmd: Command): string;
+  /** Get the description for the command. */
+  commandDescription(cmd: Command): string;
+  /** Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one. */
+  visibleCommands(cmd: Command): Command[];
+  /** Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one. */
+  visibleOptions(cmd: Command): Option[];
+  /** Get an array of the visible global options. (Not including help.) */
+  visibleGlobalOptions(cmd: Command): Option[];
+  /** Get an array of the arguments which have descriptions. */
+  visibleArguments(cmd: Command): Argument[];
+  /** Get the longest command term length. */
+  longestSubcommandTermLength(cmd: Command, helper: Help): number;
+  /** Get the longest option term length. */
+  longestOptionTermLength(cmd: Command, helper: Help): number;
+  /** Get the longest global option term length. */
+  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 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.
+   */
+  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;
+}
+type HelpConfiguration = Partial<Help>;
+interface ParseOptions {
+  from: 'node' | 'electron' | 'user';
+}
+interface HelpContext {
+  // optional parameter for .help() and .outputHelp()
+  error: boolean;
+}
+interface AddHelpTextContext {
+  // passed to text function used with .addHelpText()
+  error: boolean;
+  command: Command;
+}
+interface OutputConfiguration {
+  writeOut?(str: string): void;
+  writeErr?(str: string): void;
+  outputError?(str: string, write: (str: string) => void): void;
+  getOutHelpWidth?(): number;
+  getErrHelpWidth?(): number;
+  getOutHasColors?(): boolean;
+  getErrHasColors?(): boolean;
+  stripColor?(str: string): string;
+}
+type AddHelpTextPosition = 'beforeAll' | 'before' | 'after' | 'afterAll';
+type HookEvent = 'preSubcommand' | 'preAction' | 'postAction';
+// The source is a string so author can define their own too.
+type OptionValueSource = LiteralUnion<'default' | 'config' | 'env' | 'cli' | 'implied', string> | undefined;
+type OptionValues = Record<string, any>;
+declare class Command {
+  args: string[];
+  processedArgs: any[];
+  readonly commands: readonly Command[];
+  readonly options: readonly Option[];
+  readonly registeredArguments: readonly Argument[];
+  parent: Command | null;
+  constructor(name?: string);
+  /**
+   * Set the program version to `str`.
+   *
+   * This method auto-registers the "-V, --version" flag
+   * which will print the version number when passed.
+   *
+   * You can optionally supply the  flags and description to override the defaults.
+   */
+  version(str: string, flags?: string, description?: string): this;
+  /**
+   * Get the program version.
+   */
+  version(): string | undefined;
+  /**
+   * Define a command, implemented using an action handler.
+   *
+   * @remarks
+   * The command description is supplied using `.description`, not as a parameter to `.command`.
+   *
+   * @example
+   * ```ts
+   * program
+   *   .command('clone <source> [destination]')
+   *   .description('clone a repository into a newly created directory')
+   *   .action((source, destination) => {
+   *     console.log('clone command called');
+   *   });
+   * ```
+   *
+   * @param nameAndArgs - command name and arguments, args are  `<required>` or `[optional]` and last may also be `variadic...`
+   * @param opts - configuration options
+   * @returns new command
+   */
+  command(nameAndArgs: string, opts?: CommandOptions): ReturnType<this['createCommand']>;
+  /**
+   * Define a command, implemented in a separate executable file.
+   *
+   * @remarks
+   * The command description is supplied as the second parameter to `.command`.
+   *
+   * @example
+   * ```ts
+   *  program
+   *    .command('start <service>', 'start named service')
+   *    .command('stop [service]', 'stop named service, or all if no name supplied');
+   * ```
+   *
+   * @param nameAndArgs - command name and arguments, args are  `<required>` or `[optional]` and last may also be `variadic...`
+   * @param description - description of executable command
+   * @param opts - configuration options
+   * @returns `this` command for chaining
+   */
+  command(nameAndArgs: string, description: string, opts?: ExecutableCommandOptions): this;
+  /**
+   * Factory routine to create a new unattached command.
+   *
+   * See .command() for creating an attached subcommand, which uses this routine to
+   * create the command. You can override createCommand to customise subcommands.
+   */
+  createCommand(name?: string): Command;
+  /**
+   * Add a prepared subcommand.
+   *
+   * See .command() for creating an attached subcommand which inherits settings from its parent.
+   *
+   * @returns `this` command for chaining
+   */
+  addCommand(cmd: Command, opts?: CommandOptions): this;
+  /**
+   * Factory routine to create a new unattached argument.
+   *
+   * See .argument() for creating an attached argument, which uses this routine to
+   * create the argument. You can override createArgument to return a custom argument.
+   */
+  createArgument(name: string, description?: string): Argument;
+  /**
+   * Define argument syntax for command.
+   *
+   * The default is that the argument is required, and you can explicitly
+   * indicate this with <> around the name. Put [] around the name for an optional argument.
+   *
+   * @example
+   * ```
+   * program.argument('<input-file>');
+   * program.argument('[output-file]');
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  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.
+   *
+   * @returns `this` command for chaining
+   */
+  addArgument(arg: Argument): this;
+  /**
+   * Define argument syntax for command, adding multiple at once (without descriptions).
+   *
+   * See also .argument().
+   *
+   * @example
+   * ```
+   * program.arguments('<cmd> [env]');
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  arguments(names: string): this;
+  /**
+   * Customise or override default help command. By default a help command is automatically added if your command has subcommands.
+   *
+   * @example
+   * ```ts
+   * program.helpCommand('help [cmd]');
+   * program.helpCommand('help [cmd]', 'show help');
+   * program.helpCommand(false); // suppress default help command
+   * program.helpCommand(true); // add help command even if no subcommands
+   * ```
+   */
+  helpCommand(nameAndArgs: string, description?: string): this;
+  helpCommand(enable: boolean): this;
+  /**
+   * Add prepared custom help command.
+   */
+  addHelpCommand(cmd: Command): this;
+  /** @deprecated since v12, instead use helpCommand */
+  addHelpCommand(nameAndArgs: string, description?: string): this;
+  /** @deprecated since v12, instead use helpCommand */
+  addHelpCommand(enable?: boolean): this;
+  /**
+   * Add hook for life cycle event.
+   */
+  hook(event: HookEvent, listener: (thisCommand: Command, actionCommand: Command) => void | Promise<void>): this;
+  /**
+   * Register callback to use as replacement for calling process.exit.
+   */
+  exitOverride(callback?: (err: CommanderError) => never | void): this;
+  /**
+   * Display error message and exit (or call exitOverride).
+   */
+  error(message: string, errorOptions?: ErrorOptions): never;
+  /**
+   * You can customise the help with a subclass of Help by overriding createHelp,
+   * or by overriding Help properties using configureHelp().
+   */
+  createHelp(): Help;
+  /**
+   * You can customise the help by overriding Help properties using configureHelp(),
+   * or with a subclass of Help by overriding createHelp().
+   */
+  configureHelp(configuration: HelpConfiguration): this;
+  /** Get configuration */
+  configureHelp(): HelpConfiguration;
+  /**
+   * The default output goes to stdout and stderr. You can customise this for special
+   * applications. You can also customise the display of errors by overriding outputError.
+   *
+   * The configuration properties are all functions:
+   * ```
+   * // functions to change where being written, stdout and stderr
+   * writeOut(str)
+   * writeErr(str)
+   * // matching functions to specify width for wrapping help
+   * getOutHelpWidth()
+   * getErrHelpWidth()
+   * // functions based on what is being written out
+   * outputError(str, write) // used for displaying errors, and not used for displaying help
+   * ```
+   */
+  configureOutput(configuration: OutputConfiguration): this;
+  /** Get configuration */
+  configureOutput(): OutputConfiguration;
+  /**
+   * Copy settings that are useful to have in common across root command and subcommands.
+   *
+   * (Used internally when adding a command using `.command()` so subcommands inherit parent settings.)
+   */
+  copyInheritedSettings(sourceCommand: Command): this;
+  /**
+   * Display the help or a custom message after an error occurs.
+   */
+  showHelpAfterError(displayHelp?: boolean | string): this;
+  /**
+   * Display suggestion of similar commands for unknown commands, or options for unknown options.
+   */
+  showSuggestionAfterError(displaySuggestion?: boolean): this;
+  /**
+   * Register callback `fn` for the command.
+   *
+   * @example
+   * ```
+   * program
+   *   .command('serve')
+   *   .description('start service')
+   *   .action(function() {
+   *     // do work here
+   *   });
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  action(fn: (this: this, ...args: any[]) => void | Promise<void>): this;
+  /**
+   * Define option with `flags`, `description`, and optional argument parsing function or `defaultValue` or both.
+   *
+   * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space. A required
+   * option-argument is indicated by `<>` and an optional option-argument by `[]`.
+   *
+   * See the README for more details, and see also addOption() and requiredOption().
+   *
+   * @example
+   *
+   * ```js
+   * program
+   *     .option('-p, --pepper', 'add pepper')
+   *     .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
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  option(flags: string, description?: string, defaultValue?: string | boolean | string[]): this;
+  option<T>(flags: string, description: string, parseArg: (value: string, previous: T) => T, defaultValue?: T): this;
+  /** @deprecated since v7, instead use choices or a custom function */
+  option(flags: string, description: string, regexp: RegExp, defaultValue?: string | boolean | string[]): this;
+  /**
+   * Define a required option, which must have a value after parsing. This usually means
+   * the option must be specified on the command line. (Otherwise the same as .option().)
+   *
+   * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
+   */
+  requiredOption(flags: string, description?: string, defaultValue?: string | boolean | string[]): this;
+  requiredOption<T>(flags: string, description: string, parseArg: (value: string, previous: T) => T, defaultValue?: T): this;
+  /** @deprecated since v7, instead use choices or a custom function */
+  requiredOption(flags: string, description: string, regexp: RegExp, defaultValue?: string | boolean | string[]): this;
+  /**
+   * Factory routine to create a new unattached option.
+   *
+   * See .option() for creating an attached option, which uses this routine to
+   * create the option. You can override createOption to return a custom option.
+   */
+  createOption(flags: string, description?: string): Option;
+  /**
+   * Add a prepared Option.
+   *
+   * See .option() and .requiredOption() for creating and attaching an option in a single call.
+   */
+  addOption(option: Option): this;
+  /**
+   * Whether to store option values as properties on command object,
+   * or store separately (specify false). In both cases the option values can be accessed using .opts().
+   *
+   * @returns `this` command for chaining
+   */
+  storeOptionsAsProperties<T extends OptionValues>(): this & T;
+  storeOptionsAsProperties<T extends OptionValues>(storeAsProperties: true): this & T;
+  storeOptionsAsProperties(storeAsProperties?: boolean): this;
+  /**
+   * Retrieve option value.
+   */
+  getOptionValue(key: string): any;
+  /**
+   * Store option value.
+   */
+  setOptionValue(key: string, value: unknown): this;
+  /**
+   * Store option value and where the value came from.
+   */
+  setOptionValueWithSource(key: string, value: unknown, source: OptionValueSource): this;
+  /**
+   * Get source of option value.
+   */
+  getOptionValueSource(key: string): OptionValueSource | undefined;
+  /**
+   * Get source of option value. See also .optsWithGlobals().
+   */
+  getOptionValueSourceWithGlobals(key: string): OptionValueSource | undefined;
+  /**
+   * Alter parsing of short flags with optional values.
+   *
+   * @example
+   * ```
+   * // for `.option('-f,--flag [value]'):
+   * .combineFlagAndOptionalValue(true)  // `-f80` is treated like `--flag=80`, this is the default behaviour
+   * .combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b`
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  combineFlagAndOptionalValue(combine?: boolean): this;
+  /**
+   * Allow unknown options on the command line.
+   *
+   * @returns `this` command for chaining
+   */
+  allowUnknownOption(allowUnknown?: boolean): this;
+  /**
+   * Allow excess command-arguments on the command line. Pass false to make excess arguments an error.
+   *
+   * @returns `this` command for chaining
+   */
+  allowExcessArguments(allowExcess?: boolean): this;
+  /**
+   * Enable positional options. Positional means global options are specified before subcommands which lets
+   * subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.
+   *
+   * The default behaviour is non-positional and global options may appear anywhere on the command line.
+   *
+   * @returns `this` command for chaining
+   */
+  enablePositionalOptions(positional?: boolean): this;
+  /**
+   * Pass through options that come after command-arguments rather than treat them as command-options,
+   * so actual command-options come before command-arguments. Turning this on for a subcommand requires
+   * positional options to have been enabled on the program (parent commands).
+   *
+   * The default behaviour is non-positional and options may appear before or after command-arguments.
+   *
+   * @returns `this` command for chaining
+   */
+  passThroughOptions(passThrough?: boolean): this;
+  /**
+   * Parse `argv`, setting options and invoking commands when defined.
+   *
+   * Use parseAsync instead of parse if any of your action handlers are async.
+   *
+   * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!
+   *
+   * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:
+   * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that
+   * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged
+   * - `'user'`: just user arguments
+   *
+   * @example
+   * ```
+   * program.parse(); // parse process.argv and auto-detect electron and special node flags
+   * program.parse(process.argv); // assume argv[0] is app and argv[1] is script
+   * program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  parse(argv?: readonly string[], parseOptions?: ParseOptions): this;
+  /**
+   * Parse `argv`, setting options and invoking commands when defined.
+   *
+   * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!
+   *
+   * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:
+   * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that
+   * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged
+   * - `'user'`: just user arguments
+   *
+   * @example
+   * ```
+   * await program.parseAsync(); // parse process.argv and auto-detect electron and special node flags
+   * await program.parseAsync(process.argv); // assume argv[0] is app and argv[1] is script
+   * await program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
+   * ```
+   *
+   * @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], []
+   *     sub --unknown uuu op => [sub], [--unknown uuu op]
+   *     sub -- --unknown uuu op => [sub --unknown uuu op], []
+   */
+  parseOptions(argv: string[]): ParseOptionsResult;
+  /**
+   * Return an object containing local option values as key-value pairs
+   */
+  opts<T extends OptionValues>(): T;
+  /**
+   * Return an object containing merged local and global option values as key-value pairs.
+   */
+  optsWithGlobals<T extends OptionValues>(): T;
+  /**
+   * Set the description.
+   *
+   * @returns `this` command for chaining
+   */
+  description(str: string): this;
+  /** @deprecated since v8, instead use .argument to add command argument with description */
+  description(str: string, argsDescription: Record<string, string>): this;
+  /**
+   * Get the description.
+   */
+  description(): string;
+  /**
+   * Set the summary. Used when listed as subcommand of parent.
+   *
+   * @returns `this` command for chaining
+   */
+  summary(str: string): this;
+  /**
+   * Get the summary.
+   */
+  summary(): string;
+  /**
+   * Set an alias for the command.
+   *
+   * You may call more than once to add multiple aliases. Only the first alias is shown in the auto-generated help.
+   *
+   * @returns `this` command for chaining
+   */
+  alias(alias: string): this;
+  /**
+   * Get alias for the command.
+   */
+  alias(): string;
+  /**
+   * Set aliases for the command.
+   *
+   * Only the first alias is shown in the auto-generated help.
+   *
+   * @returns `this` command for chaining
+   */
+  aliases(aliases: readonly string[]): this;
+  /**
+   * Get aliases for the command.
+   */
+  aliases(): string[];
+  /**
+   * Set the command usage.
+   *
+   * @returns `this` command for chaining
+   */
+  usage(str: string): this;
+  /**
+   * Get the command usage.
+   */
+  usage(): string;
+  /**
+   * Set the name of the command.
+   *
+   * @returns `this` command for chaining
+   */
+  name(str: string): this;
+  /**
+   * Get the name of the command.
+   */
+  name(): string;
+  /**
+   * Set the name of the command from script filename, such as process.argv[1],
+   * or import.meta.filename.
+   *
+   * (Used internally and public although not documented in README.)
+   *
+   * @example
+   * ```ts
+   * program.nameFromFilename(import.meta.filename);
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  nameFromFilename(filename: string): this;
+  /**
+   * Set the directory for searching for executable subcommands of this command.
+   *
+   * @example
+   * ```ts
+   * program.executableDir(import.meta.dirname);
+   * // or
+   * program.executableDir('subcommands');
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  executableDir(path: string): this;
+  /**
+   * 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.
+   *
+   * Outputs built-in help, and custom text added using `.addHelpText()`.
+   *
+   */
+  outputHelp(context?: HelpContext): void;
+  /** @deprecated since v7 */
+  outputHelp(cb: (str: string) => string): void;
+  /**
+   * Return command help documentation.
+   */
+  helpInformation(context?: HelpContext): string;
+  /**
+   * You can pass in flags and a description to override the help
+   * flags and help description for your command. Pass in false
+   * to disable the built-in help option.
+   */
+  helpOption(flags?: string | boolean, description?: string): this;
+  /**
+   * Supply your own option to use for the built-in help option.
+   * This is an alternative to using helpOption() to customise the flags and description etc.
+   */
+  addHelpOption(option: Option): this;
+  /**
+   * Output help information and exit.
+   *
+   * Outputs built-in help, and custom text added using `.addHelpText()`.
+   */
+  help(context?: HelpContext): never;
+  /** @deprecated since v7 */
+  help(cb: (str: string) => string): never;
+  /**
+   * Add additional text to be displayed with the built-in help.
+   *
+   * Position is 'before' or 'after' to affect just this command,
+   * and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.
+   */
+  addHelpText(position: AddHelpTextPosition, text: string): this;
+  addHelpText(position: AddHelpTextPosition, text: (context: AddHelpTextContext) => string): this;
+  /**
+   * Add a listener (callback) for when events occur. (Implemented using EventEmitter.)
+   */
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+interface CommandOptions {
+  hidden?: boolean;
+  isDefault?: boolean;
+  /** @deprecated since v7, replaced by hidden */
+  noHelp?: boolean;
+}
+interface ExecutableCommandOptions extends CommandOptions {
+  executableFile?: string;
+}
+interface ParseOptionsResult {
+  operands: string[];
+  unknown: string[];
+}
+//#endregion
+//#region src/commands/checkfeatures.d.ts
+interface CheckfeaturesOpts {
+  verbose?: number;
+}
+declare class Checkfeatures implements ICommand {
+  mapContext(_opts: CheckfeaturesOpts, context: CmContext): CmContext;
+  getTasks(context: CmContext): CmTask[];
+  success(): void;
+}
+//#endregion
+//#region src/commands/clean.d.ts
+interface CleanOpts {
+  verbose?: number;
+}
+declare class Clean implements ICommand {
+  mapContext(_opts: CleanOpts, context: CmContext): CmContext;
+  getTasks(context: CmContext): CmTask[];
+  success(): void;
+}
+//#endregion
+//#region src/commands/config.d.ts
+interface ConfigOpts {
+  verbose?: number;
+}
+declare class Config implements ICommand {
+  mapContext(_opts: ConfigOpts, context: CmContext): CmContext;
+  getTasks(context: CmContext): CmTask[];
+}
+//#endregion
+//#region src/commands/deploy.d.ts
+interface DeployOpts {
+  target?: string;
+  verbose?: number;
+}
+declare class Deploy implements ICommand {
+  mapContext(commander: DeployOpts, context: CmContext): CmContext;
+  getTasks(context: CmContext): CmTask[];
+  success(): void;
+}
+//#endregion
+//#region src/commands/fetch.d.ts
+interface FetchOpts {
+  dryRun?: boolean;
+  verbose?: number;
+}
+declare class Fetch implements ICommand {
+  mapContext(_opts: FetchOpts, context: CmContext): CmContext;
+  getTasks(context: CmContext): CmTask[];
+  success(context: CmContext): void;
+}
+//#endregion
+//#region src/commands/rebase.d.ts
+interface RebaseOpts {
+  unitTest?: number;
+  cucumber?: number;
+  force?: number;
+  verbose?: number;
+}
+declare class Rebase extends Fetch implements ICommand {
+  mapContext(commander: RebaseOpts, context: CmContext): CmContext;
+  getTasks(context: CmContext): CmTask[];
+  success(context: CmContext): void;
+}
+//#endregion
+//#region ../../node_modules/rxjs/dist/types/internal/Subscription.d.ts
+/**
+ * Represents a disposable resource, such as the execution of an Observable. A
+ * Subscription has one important method, `unsubscribe`, that takes no argument
+ * and just disposes the resource held by the subscription.
+ *
+ * Additionally, subscriptions may be grouped together through the `add()`
+ * 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.
+ */
+declare class Subscription implements SubscriptionLike {
+  private initialTeardown?;
+  static EMPTY: Subscription;
+  /**
+   * A flag to indicate whether this Subscription has already been unsubscribed.
+   */
+  closed: boolean;
+  private _parentage;
+  /**
+   * The list of registered finalizers to execute upon unsubscription. Adding and removing from this
+   * list occurs in the {@link #add} and {@link #remove} methods.
+   */
+  private _finalizers;
+  /**
+   * @param initialTeardown A function executed first as part of the finalization
+   * process that is kicked off when {@link #unsubscribe} is called.
+   */
+  constructor(initialTeardown?: (() => void) | undefined);
+  /**
+   * 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.
+   */
+  unsubscribe(): void;
+  /**
+   * Adds a finalizer to this subscription, so that finalization will be unsubscribed/called
+   * when this subscription is unsubscribed. If this subscription is already {@link #closed},
+   * because it has already been unsubscribed, then whatever finalizer is passed to it
+   * will automatically be executed (unless the finalizer itself is also a closed subscription).
+   *
+   * Closed Subscriptions cannot be added as finalizers to any subscription. Adding a closed
+   * subscription to a any subscription will result in no operation. (A noop).
+   *
+   * Adding a subscription to itself, or adding `null` or `undefined` will not perform any
+   * operation at all. (A noop).
+   *
+   * `Subscription` instances that are added to this instance will automatically remove themselves
+   * if they are unsubscribed. Functions and {@link Unsubscribable} objects that you wish to remove
+   * will need to be removed manually with {@link #remove}
+   *
+   * @param teardown The finalization logic to add to this subscription.
+   */
+  add(teardown: TeardownLogic): void;
+  /**
+   * Checks to see if a this subscription already has a particular parent.
+   * This will signal that this subscription has already been added to the parent in question.
+   * @param parent the parent to check for
+   */
+  private _hasParent;
+  /**
+   * Adds a parent to this subscription so it can be removed from the parent if it
+   * unsubscribes on it's own.
+   *
+   * NOTE: THIS ASSUMES THAT {@link _hasParent} HAS ALREADY BEEN CHECKED.
+   * @param parent The parent subscription to add
+   */
+  private _addParent;
+  /**
+   * Called on a child when it is removed via {@link #remove}.
+   * @param parent The parent to remove
+   */
+  private _removeParent;
+  /**
+   * Removes a finalizer from this subscription that was previously added with the {@link #add} method.
+   *
+   * Note that `Subscription` instances, when unsubscribed, will automatically remove themselves
+   * from every other `Subscription` they have been added to. This means that using the `remove` method
+   * is not a common thing and should be used thoughtfully.
+   *
+   * If you add the same finalizer instance of a function or an unsubscribable object to a `Subscription` instance
+   * more than once, you will need to call `remove` the same number of times to remove all instances.
+   *
+   * All finalizer instances are removed to free up memory upon unsubscription.
+   *
+   * @param teardown The finalizer to remove from this subscription
+   */
+  remove(teardown: Exclude<TeardownLogic, void>): void;
+}
+//#endregion
+//#region ../../node_modules/rxjs/dist/types/internal/types.d.ts
+/**
+ * Note: This will add Symbol.observable globally for all TypeScript users,
+ * however, we are no longer polyfilling Symbol.observable
+ */
+declare global {
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
+}
+/**
+ * A function type interface that describes a function that accepts one parameter `T`
+ * and returns another parameter `R`.
+ *
+ * Usually used to describe {@link OperatorFunction} - it always takes a single
+ * parameter (the source Observable) and returns another Observable.
+ */
+interface UnaryFunction<T, R> {
+  (source: T): R;
+}
+interface OperatorFunction<T, R> extends UnaryFunction<Observable<T>, Observable<R>> {}
+interface Unsubscribable {
+  unsubscribe(): void;
+}
+declare type TeardownLogic = Subscription | Unsubscribable | (() => void) | void;
+interface SubscriptionLike extends Unsubscribable {
+  unsubscribe(): void;
+  readonly closed: boolean;
+}
+/** OBSERVABLE INTERFACES */
+interface Subscribable<T> {
+  subscribe(observer: Partial<Observer<T>>): Unsubscribable;
+}
+/**
+ * An object interface that defines a set of callback functions a user can use to get
+ * notified of any set of {@link Observable}
+ * {@link guide/glossary-and-semantics#notification notification} events.
+ *
+ * For more info, please refer to {@link guide/observer this guide}.
+ */
+interface Observer<T> {
+  /**
+   * A callback function that gets called by the producer during the subscription when
+   * the producer "has" the `value`. It won't be called if `error` or `complete` callback
+   * functions have been called, nor after the consumer has unsubscribed.
+   *
+   * For more info, please refer to {@link guide/glossary-and-semantics#next this guide}.
+   */
+  next: (value: T) => void;
+  /**
+   * A callback function that gets called by the producer if and when it encountered a
+   * problem of any kind. The errored value will be provided through the `err` parameter.
+   * This callback can't be called more than one time, it can't be called if the
+   * `complete` callback function have been called previously, nor it can't be called if
+   * the consumer has unsubscribed.
+   *
+   * For more info, please refer to {@link guide/glossary-and-semantics#error this guide}.
+   */
+  error: (err: any) => void;
+  /**
+   * A callback function that gets called by the producer if and when it has no more
+   * values to provide (by calling `next` callback function). This means that no error
+   * has happened. This callback can't be called more than one time, it can't be called
+   * if the `error` callback function have been called previously, nor it can't be called
+   * if the consumer has unsubscribed.
+   *
+   * For more info, please refer to {@link guide/glossary-and-semantics#complete this guide}.
+   */
+  complete: () => void;
+}
+//#endregion
+//#region ../../node_modules/rxjs/dist/types/internal/Subscriber.d.ts
+/**
+ * Implements the {@link Observer} interface and extends the
+ * {@link Subscription} class. While the {@link Observer} is the public API for
+ * consuming the values of an {@link Observable}, all Observers get converted to
+ * 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.
+ */
+declare class Subscriber<T> extends Subscription implements Observer<T> {
+  /**
+   * A static factory for a Subscriber, given a (potentially partial) definition
+   * of an Observer.
+   * @param next The `next` callback of an Observer.
+   * @param error The `error` callback of an
+   * Observer.
+   * @param complete The `complete` callback of an
+   * Observer.
+   * @return A Subscriber wrapping the (partially defined)
+   * Observer represented by the given arguments.
+   * @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.
+   */
+  static create<T>(next?: (x?: T) => void, error?: (e?: any) => void, complete?: () => void): Subscriber<T>;
+  /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+  protected isStopped: boolean;
+  /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+  protected destination: Subscriber<any> | Observer<any>;
+  /**
+   * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+   * There is no reason to directly create an instance of Subscriber. This type is exported for typings reasons.
+   */
+  constructor(destination?: Subscriber<any> | Observer<any>);
+  /**
+   * 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 value The `next` value.
+   */
+  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 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.
+   */
+  complete(): void;
+  unsubscribe(): void;
+  protected _next(value: T): void;
+  protected _error(err: any): void;
+  protected _complete(): void;
+}
+//#endregion
+//#region ../../node_modules/rxjs/dist/types/internal/Operator.d.ts
+/***
+ * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+ */
+interface Operator<T, R> {
+  call(subscriber: Subscriber<R>, source: any): TeardownLogic;
+}
+//#endregion
+//#region ../../node_modules/rxjs/dist/types/internal/Observable.d.ts
+/**
+ * A representation of any set of values over any amount of time. This is the most basic building block
+ * of RxJS.
+ */
+declare class Observable<T> implements Subscribable<T> {
+  /**
+   * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+   */
+  source: Observable<any> | undefined;
+  /**
+   * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+   */
+  operator: Operator<any, T> | undefined;
+  /**
+   * @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.
+   */
+  constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
+  /**
+   * Creates a new Observable by calling the Observable constructor
+   * @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.
+   * @param operator the operator defining the operation to take on the observable
+   * @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
+   * scratch" section here: https://rxjs.dev/guide/operators
+   */
+  lift<R>(operator?: Operator<T, R>): Observable<R>;
+  subscribe(observerOrNext?: Partial<Observer<T>> | ((value: T) => void)): Subscription;
+  /** @deprecated Instead of passing separate callback arguments, use an observer argument. Signatures taking separate callback arguments will be removed in v8. Details: https://rxjs.dev/deprecations/subscribe-arguments */
+  subscribe(next?: ((value: T) => void) | null, error?: ((error: any) => void) | null, complete?: (() => void) | null): Subscription;
+  /**
+   * Used as a NON-CANCELLABLE means of subscribing to an observable, for use with
+   * APIs that expect promises, like `async/await`. You cannot unsubscribe from this.
+   *
+   * **WARNING**: Only use this with observables you *know* will complete. If the source
+   * observable does not complete, you will end up with a promise that is hung up, and
+   * potentially all of the state of an async function hanging out in memory. To avoid
+   * this situation, look into adding something like {@link timeout}, {@link take},
+   * {@link takeWhile}, or {@link takeUntil} amongst others.
+   *
+   * #### Example
+   *
+   * ```ts
+   * import { interval, take } from 'rxjs';
+   *
+   * const source$ = interval(1000).pipe(take(4));
+   *
+   * async function getTotal() {
+   *   let total = 0;
+   *
+   *   await source$.forEach(value => {
+   *     total += value;
+   *     console.log('observable -> ' + value);
+   *   });
+   *
+   *   return total;
+   * }
+   *
+   * getTotal().then(
+   *   total => console.log('Total: ' + total)
+   * );
+   *
+   * // Expected:
+   * // 'observable -> 0'
+   * // 'observable -> 1'
+   * // 'observable -> 2'
+   * // 'observable -> 3'
+   * // '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.
+   */
+  forEach(next: (value: T) => void): Promise<void>;
+  /**
+   * @param next a handler for each value emitted by the observable
+   * @param promiseCtor a constructor function used to instantiate the Promise
+   * @return a promise that either resolves on observable completion or
+   *  rejects with the handled error
+   * @deprecated Passing a Promise constructor will no longer be available
+   * in upcoming versions of RxJS. This is because it adds weight to the library, for very
+   * little benefit. If you need this functionality, it is recommended that you either
+   * polyfill Promise, or you create an adapter to convert the returned native promise
+   * to whatever promise implementation you wanted. Will be removed in v8.
+   */
+  forEach(next: (value: T) => void, promiseCtor: PromiseConstructorLike): Promise<void>;
+  pipe(): Observable<T>;
+  pipe<A>(op1: OperatorFunction<T, A>): Observable<A>;
+  pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>;
+  pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>;
+  pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Observable<D>;
+  pipe<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Observable<E>;
+  pipe<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Observable<F>;
+  pipe<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Observable<G>;
+  pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Observable<H>;
+  pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Observable<I>;
+  pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): Observable<unknown>;
+  /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+  toPromise(): Promise<T | undefined>;
+  /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+  toPromise(PromiseCtor: typeof Promise): Promise<T | undefined>;
+  /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+  toPromise(PromiseCtor: PromiseConstructorLike): Promise<T | undefined>;
+}
+//#endregion
+//#region src/commands/tasks/push-branch.d.ts
+type PushBranchContext = CmContext<{
+  origin?: string;
+  featureBranch?: string;
+  upstream?: boolean;
+  noVerify?: boolean;
+}>;
+//#endregion
+//#region src/commands/finish.d.ts
+declare class Finish extends Rebase implements ICommand {
+  mapContext(commander: RebaseOpts, context: CmContext): CmContext;
+  verifyConditions(context: CmContext): void;
+  getTasks(context: PushBranchContext & RebaseOpts): CmTask[];
+  success(context: CmContext): void;
+}
+//#endregion
+//#region src/commands/jira-releases.d.ts
+interface JiraReleasesOpts {
+  component?: string;
+  projectId?: string;
+  update?: number;
+  verbose?: number;
+  tag?: string;
+}
+interface JiraRelease {
+  id: string;
+  name: string;
+  released: boolean;
+  releaseDate?: string;
+  version: string;
+  [key: string]: unknown;
+}
+type JiraReleasesContext = CmContext<{
+  projectId?: string;
+  component?: string;
+  tag?: string;
+  update?: number;
+  releases?: JiraRelease[];
+}>;
+declare class JiraReleases implements ICommand {
+  mapContext(commander: JiraReleasesOpts, context: CmContext): JiraReleasesContext;
+  getTasks(context: JiraReleasesContext): CmTask[];
+}
+//#endregion
+//#region src/commands/merge.d.ts
+declare class Merge implements ICommand {
+  private lastCommitMessage;
+  getTasks(context: CmContext): CmTask[];
+  success(context: CmContext): void;
+}
+//#endregion
+//#region src/commands/packages.d.ts
+declare class Packages implements ICommand {
+  mapContext(options: Record<string, unknown>, context: CmContext): CmContext;
+  getTasks(context: CmContext): CmTask[];
+}
+//#endregion
+//#region src/commands/pull.d.ts
+declare class Pull implements ICommand {
+  mapContext(options: Record<string, unknown>, context: CmContext): CmContext;
+  getTasks(context: CmContext): CmTask[];
+  success(context: CmContext): void;
+}
+//#endregion
+//#region src/commands/push.d.ts
+declare class Push extends Rebase implements ICommand {
+  mapContext(commander: RebaseOpts, context: CmContext): CmContext;
+  getTasks(context: CmContext): CmTask[];
+  success(context: CmContext): void;
+}
+declare const publish: (program: Command) => void;
+//#endregion
+//#region src/commands/republish.d.ts
+interface RepublishOpts {
+  verbose?: number;
+}
+declare class Republish extends Fetch implements ICommand {
+  mapContext(commander: RepublishOpts, context: CmContext): CmContext;
+  getTasks(context: CmContext): CmTask[];
+  success(): void;
+}
+//#endregion
+//#region src/commands/start.d.ts
+interface StartOpts {
+  jiraId?: string;
+  branchName?: string;
+  dryRun?: boolean;
+  verbose?: number;
+}
+type StartContext = CmContext<{
+  jiraId?: string;
+  branchName?: string;
+  type?: string;
+  featureBranch?: string;
+  fromBranch?: string;
+  origin?: string;
+}>;
+declare class Start extends Fetch implements ICommand {
+  mapContext(options: StartOpts, context: CmContext): StartContext;
+  prompt(context: StartContext): Promise<Record<string, unknown> | symbol>;
+  getTasks(context: StartContext): CmTask[];
+  success(context: StartContext): void;
+}
+declare namespace index_d_exports {
+  export { Checkfeatures, Clean, Config, Deploy, Fetch, Finish, JiraRelease, JiraReleases, Merge, Packages, Pull, Push, Rebase, RebaseOpts, Republish, Start, publish };
+}
+//#endregion
+//#region src/commands/release.d.ts
+declare function release(options?: {}): void;
+//#endregion
+//#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.
+		*/
+  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.
+
+	@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.
+
+		This requires the `ipc` option to be `true`. The type of `message` depends on the `serialization` option.
+		*/
+  sendMessage(message: Message<Serialization>, sendMessageOptions?: SendMessageOptions): Promise<void>;
+  /**
+		Receive a single `message` from the subprocess.
+
+		This requires the `ipc` option to be `true`. The type of `message` depends on the `serialization` option.
+		*/
+  getOneMessage(getOneMessageOptions?: GetOneMessageOptions<Serialization>): Promise<Message<Serialization>>;
+  /**
+		Iterate over each `message` from the subprocess.
+
+		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)).
+
+	This is `undefined` if the `stdout` option is set to only `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
+
+	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)).
+
+	This is `undefined` if the `stderr` option is set to only `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
+
+	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.
+
+	This requires the `all` option to be `true`.
+
+	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`.
+
+	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.
+
+	Items are `undefined` when their corresponding `stdio` option is set to only `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
+
+	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.
+
+	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.
+
+	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.
+
+	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.
+
+	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).
+
+	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.
+
+	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.
+
+	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)`.
+
+	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.
+
+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.
+
+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'`.
+
+	This is helpful when multiple subprocesses are running at the same time.
+
+	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 `true` with `$`, `false` otherwise
+	*/
+  readonly preferLocal?: boolean;
+  /**
+	Preferred path to find locally installed binaries, when using the `preferLocal` option.
+
+	@default `cwd` option
+	*/
+  readonly localDir?: string | URL;
+  /**
+	If `true`, runs with Node.js. The first argument must be a Node.js file.
+
+	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 `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.
+
+	Requires the `node` option to be `true`.
+
+	@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.
+
+	Requires the `node` option to be `true`.
+
+	@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)).
+
+	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.
+
+	We recommend against using this option.
+
+	@default false
+	*/
+  readonly shell?: boolean | string | URL;
+  /**
+	Current [working directory](https://en.wikipedia.org/wiki/Working_directory) of the subprocess.
+
+	This is also used to resolve the `nodePath` option when it is a relative path.
+
+	@default process.cwd()
+	*/
+  readonly cwd?: string | URL;
+  /**
+	[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)).
+
+	@default [process.env](https://nodejs.org/api/process.html#processenv)
+	*/
+  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`.
+
+	@default true
+	*/
+  readonly extendEnv?: boolean;
+  /**
+	Write some input to the subprocess' [`stdin`](https://en.wikipedia.org/wiki/Standard_streams#Standard_input_(stdin)).
+
+	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)).
+
+	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 can be an array of values such as `['inherit', 'pipe']` or `[fileUrl, 'pipe']`.
+
+	@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`.
+
+	This can be an array of values such as `['inherit', 'pipe']` or `[fileUrl, 'pipe']`.
+
+	@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>>;
+  /**
+	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'}`.
+
+	A single string can be used as a shortcut.
+
+	The array can have more than 3 items, to create additional file descriptors beyond `stdin`/`stdout`/`stderr`.
+
+	@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`.
+
+	@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).
+
+	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.
+
+	The output is available with `result.stdout`, `result.stderr` and `result.stdio`.
+
+	@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.
+
+	This cannot be used if the `encoding` option is binary.
+
+	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.
+	*/
+  readonly ipcInput?: Unless<IsSync, Message>;
+  /**
+	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.
+
+	@default 'none'
+	*/
+  readonly verbose?: VerboseOption;
+  /**
+	Setting this to `false` resolves the result's promise with the error instead of rejecting it.
+
+	@default true
+	*/
+  readonly reject?: boolean;
+  /**
+	If `timeout` is greater than `0`, the subprocess will be terminated if it runs for longer than that amount of milliseconds.
+
+	On timeout, `error.timedOut` becomes `true`.
+
+	@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.
+
+	When aborted, `error.isCanceled` becomes `true`.
+
+	@example
+	```
+	import {execaNode} from 'execa';
+
+	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;
+	}
+	```
+	*/
+  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 = {
+  /**
+	Which stream to write to the subprocess. A [file descriptor](https://en.wikipedia.org/wiki/File_descriptor) like `"fd3"` can also be passed.
+
+	@default 'stdin'
+	*/
+  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> = {
+  /**
+	Stream combining/interleaving `subprocess.stdout` and `subprocess.stderr`.
+
+	This requires the `all` option to be `true`.
+
+	This is `undefined` if `stdout` and `stderr` options are set to `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
+	*/
+  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): ReturnType<typeof execa>;
+  cwd(cwd: string): CliResult;
+  sync(opt?: RunOptions): CliSyncResult;
+  getRaw(opt?: RunOptions): string;
+  get(opt?: RunOptions): string;
+}
+declare class Cli {
+  cmd: string;
+  constructor(cmd: string);
+  sync(...args: string[]): CliSyncResult;
+  run(...args: string[]): CliResult;
+  get(...args: string[]): string;
+  static run(cmd: string, args?: string[], options?: RunOptions): CliResult;
+  static getRaw(cmd: string, args: string[], options?: RunOptions): string;
+}
+//#endregion
+//#region src/common/cli/bun.d.ts
+declare class BunCli extends Cli {
+  constructor();
+  newVersion(version: string): CliSyncResult;
+  pm(...args: string[]): CliSyncResult;
+  run(...args: string[]): CliResult;
+  install(...args: string[]): CliResult;
+  /**
+   * Reinstall dependencies without bun.lock mutation
+   * @returns {Promise<unknown>}
+   */
+  restore(): CliResult;
+}
+declare const bun: BunCli;
+//#endregion
+//#region src/common/cli/docker.d.ts
+declare class DockerCli extends Cli {
+  constructor();
+  tag(...args: string[]): string;
+  login(...args: string[]): CliSyncResult;
+  push(...args: string[]): CliResult;
+  getToken(username: string, password: string): Promise<any>;
+  getTags({ token, repository }: {
+    token: string;
+    repository: string;
+  }): Promise<any>;
+  deleteTag(tag: string, { token, repository }: {
+    token: string;
+    repository: string;
+  }): Promise<void>;
+}
+declare const docker: DockerCli;
+//#endregion
+//#region src/common/cli/git.d.ts
+declare class GitCli extends Cli {
+  constructor();
+  init(...args: string[]): CliResult;
+  add(...args: string[]): CliResult;
+  status(...args: string[]): CliSyncResult;
+  branch(...args: string[]): CliResult;
+  clean(...args: string[]): CliResult;
+  config(...args: string[]): string;
+  checkout(...args: string[]): CliResult;
+  commit(...args: string[]): CliResult;
+  fetch(...args: string[]): CliResult;
+  prune(...args: string[]): CliResult;
+  merge(...args: string[]): CliSyncResult;
+  reset(...args: string[]): CliSyncResult;
+  remote(...args: string[]): CliResult;
+  rebase(...args: string[]): CliResult;
+  getCommitTag(ref?: string): string;
+  getBranchName(ref?: string): string;
+  getLastCommitMsg(): string;
+  push(...args: string[]): CliResult;
+  branchExists(branch: string, origin?: string): boolean;
+  checkBranchRemoteStatus(branch: string, origin?: string): string;
+  branches(...args: string[]): string[];
+  show(branch: string): string;
+  branchesInfos(...args: string[]): {
+    branch: string;
+    date: string;
+    creation: string;
+    author: string;
+  }[];
+}
+declare const git: GitCli;
+//#endregion
+//#region src/common/cli/lerna.d.ts
+declare class LernaCli extends Cli {
+  constructor();
+  newVersion(version: string): CliSyncResult;
+  version(...args: string[]): CliSyncResult;
+  run(...args: string[]): CliResult;
+  install(...args: string[]): CliResult;
+}
+declare const lerna: LernaCli;
+//#endregion
+//#region src/common/cli/npm.d.ts
+declare class NpmCli extends Cli {
+  constructor();
+  newVersion(version: string): CliSyncResult;
+  version(...args: string[]): CliSyncResult;
+  run(...args: string[]): CliResult;
+  install(...args: string[]): CliResult;
+  publish(...args: string[]): CliResult;
+  pack(...args: string[]): CliResult;
+  /**
+   * Reinstall dependencies without package-lock mutation
+   * @returns {Promise<unknown>}
+   */
+  restore(): CliResult;
+}
+declare const npm: NpmCli;
+//#endregion
+//#region src/common/cli/pnpm.d.ts
+declare class PnpmCli extends Cli {
+  constructor();
+  newVersion(version: string): CliSyncResult;
+  version(...args: string[]): CliSyncResult;
+  run(...args: string[]): CliResult;
+  install(...args: string[]): CliResult;
+  /**
+   * Reinstall dependencies without pnpm-lock.yaml mutation
+   * @returns {Promise<unknown>}
+   */
+  restore(): CliResult;
+}
+declare const pnpm: PnpmCli;
+//#endregion
+//#region src/common/cli/yarn.d.ts
+declare class YarnCli extends Cli {
+  constructor();
+  newVersion(version: string): CliSyncResult;
+  version(...args: string[]): CliSyncResult;
+  run(...args: string[]): CliResult;
+  install(...args: string[]): CliResult;
+  /**
+   * Reinstall dependencies without yarn.lock mutation
+   * @returns {Promise<unknown>}
+   */
+  restore(): CliResult;
+}
+declare const yarn: YarnCli;
+//#endregion
+//#region src/common/configure-git-workspace.d.ts
+declare function configureGitWorkspace(context: CmContext): void;
+//#endregion
+//#region src/common/get-package-json.d.ts
+declare function getPackageJson(): PackageJson;
+//#endregion
+//#region src/common/get-package-manager.d.ts
+interface PackageManager extends Cli {
+  newVersion(version: string): CliSyncResult;
+  run(...args: string[]): CliResult;
+  install(...args: string[]): CliResult;
+  restore(): CliResult;
+}
+declare function getPackageManager(pkgManager: string): PackageManager;
+//#endregion
+//#region src/common/run-command.d.ts
+declare function runCommand(klass: CommandConstructor, opts: Record<string, any>): Promise<void>;
+//#endregion
+//#region src/semantic/define-config.d.ts
+type ReleasePluginContext = SemanticContext & {
+  nextRelease: NextRelease;
+};
+interface ConditionalPluginOptions {
+  when?: (context: ReleasePluginContext) => boolean;
+  [key: string]: unknown;
+}
+type Plugin = string | [string, ConditionalPluginOptions];
+interface CmReleaseConfig extends Options {
+  verifyConditions?: readonly Plugin[];
+  analyzeCommits?: readonly Plugin[];
+  verifyRelease?: readonly Plugin[];
+  generateNotes?: readonly Plugin[];
+  prepare?: readonly Plugin[];
+  publish?: readonly Plugin[];
+  success?: readonly Plugin[];
+  fail?: readonly Plugin[];
+}
+/**
+ * Define the semantic-release configuration based on the ClubMed API configuration.
+ */
+declare function defineConfig(opts?: CmReleaseConfig): CmReleaseConfig;
+//#endregion
+//#region src/semantic/utils/release-rules.d.ts
+declare const releaseRules: (import("lodash").Omit<{
+  type: string;
+  label: string;
+  release: string;
+} | {
+  type: string;
+  label: string;
+  release: boolean;
+}, "label"> | {
+  breaking: boolean;
+  release: string;
+  revert?: undefined;
+} | {
+  breaking?: undefined;
+  revert: boolean;
+  release: string;
+})[];
+//#endregion
+//#region src/semantic/utils/transform-writer.d.ts
+interface Commit {
+  type: string;
+  message?: string;
+  subject?: string;
+  scope?: string;
+  hash?: string;
+  shortHash?: string;
+  notes: Array<{
+    title: string;
+  }>;
+  references: Array<{
+    issue: string;
+  }>;
+  [key: string]: unknown;
+}
+interface TransformContext {
+  repository?: string;
+  host?: string;
+  owner?: string;
+  repoUrl?: string;
+}
+declare function transformWriter(commit: Commit, context: TransformContext): Commit | undefined;
+//#endregion
+//#region src/workflow/index.d.ts
+declare const WORKFLOW_CONFIGURATION: ({
+  type: string;
+  label: string;
+  release: string;
+} | {
+  type: string;
+  label: string;
+  release: boolean;
+})[];
+//#endregion
+//#region src/index.d.ts
+declare global {
+  const __VERSION__: string;
+}
+//#endregion
+export { Cli, CliConfig, CliResult, CliSyncResult, CmReleaseConfig, ConditionalPluginOptions, PackageManager, ReleasePluginContext, WORKFLOW_CONFIGURATION, bun, index_d_exports as commands, configureGitWorkspace, defineConfig, docker, getCI, getConfig, getPackageJson, getPackageManager, git, lerna, npm, pnpm, release, releaseRules, runCommand, transformWriter, yarn };
+//# sourceMappingURL=index.d.mts.map