@cmflow/cli 3.4.0-beta.2 → 3.4.0-beta.4

package/dist/index.d.mts

@@ -0,0 +1,2088 @@
+/// <reference path="operators/index.d.ts" />
+/// <reference path="testing/index.d.ts" />
+/// <reference types="node"/>
+import { 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-MmHuVKDa.mjs";
+import { ChildProcess } from "child_process";
+import { Readable, Stream } from "stream";
+//#region ../../node_modules/commander/typings/index.d.ts
+// Type definitions for commander
+// Original definitions by: Alan Agius <https://github.com/alan-agius4>, Marcelo Dezem <https://github.com/mdezem>, vvakame <https://github.com/vvakame>, Jules Randolph <https://github.com/sveinburne>
+// Using method rather than property for method-signature-style, to document method overloads separately. Allow either.
+/* eslint-disable @typescript-eslint/method-signature-style */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// This is a trick to encourage editor to suggest the known literals while still
+// allowing any BaseType value.
+// 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;
+  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[];
+  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 a object attribute key.
+   */
+  attributeName(): string;
+  /**
+   * 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;
+  sortSubcommands: boolean;
+  sortOptions: boolean;
+  showGlobalOptions: boolean;
+  constructor();
+  /** 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;
+  /** Calculate the pad width from the maximum term length. */
+  padWidth(cmd: Command, helper: Help): number;
+  /**
+   * Wrap the given string to width characters per line, with lines after the first indented.
+   * Do not wrap if insufficient room for wrapping (minColumnWidth), or string is manually formatted.
+   */
+  wrap(str: string, width: number, indent: number, minColumnWidth?: number): string;
+  /** 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;
+  getOutHelpWidth?(): number;
+  getErrHelpWidth?(): number;
+  outputError?(str: string, write: (str: string) => void): void;
+}
+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, fn: (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: (...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('-p, --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>;
+  /**
+   * Parse options from `argv` removing known options,
+   * and return argv split into operands and unknown arguments.
+   *
+   *     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 require.main.filename, or __filename.
+   *
+   * (Used internally and public although not documented in README.)
+   *
+   * @example
+   * ```ts
+   * program.nameFromFilename(require.main.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(__dirname);
+   * // or
+   * program.executableDir('subcommands');
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  executableDir(path: string): this;
+  /**
+   * Get the executable search directory.
+   */
+  executableDir(): string | null;
+  /**
+   * 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.
+ *
+ * @class Subscription
+ */
+declare class Subscription implements SubscriptionLike {
+  private initialTeardown?;
+  /** @nocollapse */
+  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.
+   * @return {void}
+   */
+  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.
+ *
+ * @class Subscriber<T>
+ */
+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.
+   * @nocollapse
+   * @deprecated Do not use. Will be removed in v8. There is no replacement for this
+   * method, and there is no reason to be creating instances of `Subscriber` directly.
+   * If you have a specific use case, please file an issue.
+   */
+  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 {T} [value] The `next` value.
+   * @return {void}
+   */
+  next(value?: T): void;
+  /**
+   * The {@link Observer} callback to receive notifications of type `error` from
+   * the Observable, with an attached `Error`. Notifies the Observer that
+   * the Observable has experienced an error condition.
+   * @param {any} [err] The `error` exception.
+   * @return {void}
+   */
+  error(err?: any): void;
+  /**
+   * The {@link Observer} callback to receive a valueless notification of type
+   * `complete` from the Observable. Notifies the Observer that the Observable
+   * has finished sending push-based notifications.
+   * @return {void}
+   */
+  complete(): void;
+  unsubscribe(): void;
+  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.
+ *
+ * @class Observable<T>
+ */
+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;
+  /**
+   * @constructor
+   * @param {Function} 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
+   * @owner Observable
+   * @method create
+   * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
+   * @return {Observable} a new observable
+   * @nocollapse
+   * @deprecated Use `new Observable()` instead. Will be removed in v8.
+   */
+  static create: (...args: any[]) => any;
+  /**
+   * Creates a new Observable, with this Observable instance as the source, and the passed
+   * operator defined as the new observable's operator.
+   * @method lift
+   * @param operator the operator defining the operation to take on the observable
+   * @return a new observable with the Operator applied
+   * @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/index.d.ts
+declare namespace execa {
+  type StdioOption = 'pipe' | 'ipc' | 'ignore' | 'inherit' | Stream | number | undefined;
+  interface CommonOptions<EncodingType> {
+    /**
+		Kill the spawned process when the parent process exits unless either:
+			- the spawned process is [`detached`](https://nodejs.org/api/child_process.html#child_process_options_detached)
+			- the parent process is terminated abruptly, for example, with `SIGKILL` as opposed to `SIGTERM` or a normal exit
+
+		@default true
+		*/
+    readonly cleanup?: boolean;
+    /**
+		Prefer locally installed binaries when looking for a binary to execute.
+
+		If you `$ npm install foo`, you can then `execa('foo')`.
+
+		@default false
+		*/
+    readonly preferLocal?: boolean;
+    /**
+		Preferred path to find locally installed binaries in (use with `preferLocal`).
+
+		@default process.cwd()
+		*/
+    readonly localDir?: string;
+    /**
+		Path to the Node.js executable to use in child processes.
+
+		This can be either an absolute path or a path relative to the `cwd` option.
+
+		Requires `preferLocal` to be `true`.
+
+		For example, this can be used together with [`get-node`](https://github.com/ehmicky/get-node) to run a specific Node.js version in a child process.
+
+		@default process.execPath
+		*/
+    readonly execPath?: string;
+    /**
+		Buffer the output from the spawned process. When set to `false`, you must read the output of `stdout` and `stderr` (or `all` if the `all` option is `true`). Otherwise the returned promise will not be resolved/rejected.
+
+		If the spawned process fails, `error.stdout`, `error.stderr`, and `error.all` will contain the buffered data.
+
+		@default true
+		*/
+    readonly buffer?: boolean;
+    /**
+		Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+
+		@default 'pipe'
+		*/
+    readonly stdin?: StdioOption;
+    /**
+		Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+
+		@default 'pipe'
+		*/
+    readonly stdout?: StdioOption;
+    /**
+		Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).
+
+		@default 'pipe'
+		*/
+    readonly stderr?: StdioOption;
+    /**
+		Setting this to `false` resolves the promise with the error instead of rejecting it.
+
+		@default true
+		*/
+    readonly reject?: boolean;
+    /**
+		Add an `.all` property on the promise and the resolved value. The property contains the output of the process with `stdout` and `stderr` interleaved.
+
+		@default false
+		*/
+    readonly all?: boolean;
+    /**
+		Strip the final [newline character](https://en.wikipedia.org/wiki/Newline) from the output.
+
+		@default true
+		*/
+    readonly stripFinalNewline?: boolean;
+    /**
+		Set to `false` if you don't want to extend the environment variables when providing the `env` property.
+
+		@default true
+		*/
+    readonly extendEnv?: boolean;
+    /**
+		Current working directory of the child process.
+
+		@default process.cwd()
+		*/
+    readonly cwd?: string;
+    /**
+		Environment key-value pairs. Extends automatically from `process.env`. Set `extendEnv` to `false` if you don't want this.
+
+		@default process.env
+		*/
+    readonly env?: NodeJS.ProcessEnv;
+    /**
+		Explicitly set the value of `argv[0]` sent to the child process. This will be set to `command` or `file` if not specified.
+		*/
+    readonly argv0?: string;
+    /**
+		Child's [stdio](https://nodejs.org/api/child_process.html#child_process_options_stdio) configuration.
+
+		@default 'pipe'
+		*/
+    readonly stdio?: 'pipe' | 'ignore' | 'inherit' | readonly StdioOption[];
+    /**
+		Specify the kind of serialization used for sending messages between processes when using the `stdio: 'ipc'` option or `execa.node()`:
+			- `json`: Uses `JSON.stringify()` and `JSON.parse()`.
+			- `advanced`: Uses [`v8.serialize()`](https://nodejs.org/api/v8.html#v8_v8_serialize_value)
+
+		Requires Node.js `13.2.0` or later.
+
+		[More info.](https://nodejs.org/api/child_process.html#child_process_advanced_serialization)
+
+		@default 'json'
+		*/
+    readonly serialization?: 'json' | 'advanced';
+    /**
+		Prepare child to run independently of its parent process. Specific behavior [depends on the platform](https://nodejs.org/api/child_process.html#child_process_options_detached).
+
+		@default false
+		*/
+    readonly detached?: boolean;
+    /**
+		Sets the user identity of the process.
+		*/
+    readonly uid?: number;
+    /**
+		Sets the group identity of the process.
+		*/
+    readonly gid?: number;
+    /**
+		If `true`, runs `command` inside of a shell. Uses `/bin/sh` on UNIX and `cmd.exe` on Windows. A different shell can be specified as a string. The shell should understand the `-c` switch on UNIX or `/d /s /c` on Windows.
+
+		We recommend against using this option since it is:
+		- not cross-platform, encouraging shell-specific syntax.
+		- slower, because of the additional shell interpretation.
+		- unsafe, potentially allowing command injection.
+
+		@default false
+		*/
+    readonly shell?: boolean | string;
+    /**
+		Specify the character encoding used to decode the `stdout` and `stderr` output. If set to `null`, then `stdout` and `stderr` will be a `Buffer` instead of a string.
+
+		@default 'utf8'
+		*/
+    readonly encoding?: EncodingType;
+    /**
+		If `timeout` is greater than `0`, the parent will send the signal identified by the `killSignal` property (the default is `SIGTERM`) if the child runs longer than `timeout` milliseconds.
+
+		@default 0
+		*/
+    readonly timeout?: number;
+    /**
+		Largest amount of data in bytes allowed on `stdout` or `stderr`. Default: 100 MB.
+
+		@default 100_000_000
+		*/
+    readonly maxBuffer?: number;
+    /**
+		Signal value to be used when the spawned process will be killed.
+
+		@default 'SIGTERM'
+		*/
+    readonly killSignal?: string | number;
+    /**
+		If `true`, no quoting or escaping of arguments is done on Windows. Ignored on other platforms. This is set to `true` automatically when the `shell` option is `true`.
+
+		@default false
+		*/
+    readonly windowsVerbatimArguments?: boolean;
+    /**
+		On Windows, do not create a new console window. Please note this also prevents `CTRL-C` [from working](https://github.com/nodejs/node/issues/29837) on Windows.
+
+		@default true
+		*/
+    readonly windowsHide?: boolean;
+  }
+  interface Options<EncodingType = string> extends CommonOptions<EncodingType> {
+    /**
+		Write some input to the `stdin` of your binary.
+		*/
+    readonly input?: string | Buffer | Readable;
+  }
+  interface SyncOptions<EncodingType = string> extends CommonOptions<EncodingType> {
+    /**
+		Write some input to the `stdin` of your binary.
+		*/
+    readonly input?: string | Buffer;
+  }
+  interface NodeOptions<EncodingType = string> extends Options<EncodingType> {
+    /**
+		The Node.js executable to use.
+
+		@default process.execPath
+		*/
+    readonly nodePath?: string;
+    /**
+		List of [CLI options](https://nodejs.org/api/cli.html#cli_options) passed to the Node.js executable.
+
+		@default process.execArgv
+		*/
+    readonly nodeOptions?: string[];
+  }
+  interface ExecaReturnBase<StdoutStderrType> {
+    /**
+		The file and arguments that were run, for logging purposes.
+
+		This is not escaped and should not be executed directly as a process, including using `execa()` or `execa.command()`.
+		*/
+    command: string;
+    /**
+		Same as `command` but escaped.
+
+		This is meant to be copy and pasted into a shell, for debugging purposes.
+		Since the escaping is fairly basic, this should not be executed directly as a process, including using `execa()` or `execa.command()`.
+		*/
+    escapedCommand: string;
+    /**
+		The numeric exit code of the process that was run.
+		*/
+    exitCode: number;
+    /**
+		The output of the process on stdout.
+		*/
+    stdout: StdoutStderrType;
+    /**
+		The output of the process on stderr.
+		*/
+    stderr: StdoutStderrType;
+    /**
+		Whether the process failed to run.
+		*/
+    failed: boolean;
+    /**
+		Whether the process timed out.
+		*/
+    timedOut: boolean;
+    /**
+		Whether the process was killed.
+		*/
+    killed: boolean;
+    /**
+		The name of the signal that was used to terminate the process. For example, `SIGFPE`.
+
+		If a signal terminated the process, this property is defined and included in the error message. Otherwise it is `undefined`.
+		*/
+    signal?: string;
+    /**
+		A human-friendly description of the signal that was used to terminate the process. For example, `Floating point arithmetic error`.
+
+		If a signal terminated the process, this property is defined and included in the error message. Otherwise it is `undefined`. It is also `undefined` when the signal is very uncommon which should seldomly happen.
+		*/
+    signalDescription?: string;
+  }
+  interface ExecaSyncReturnValue<StdoutErrorType = string> extends ExecaReturnBase<StdoutErrorType> {}
+  /**
+	Result of a child process execution. On success this is a plain object. On failure this is also an `Error` instance.
+
+	The child process fails when:
+	- its exit code is not `0`
+	- it was killed with a signal
+	- timing out
+	- being canceled
+	- there's not enough memory or there are already too many child processes
+	*/
+  interface ExecaReturnValue<StdoutErrorType = string> extends ExecaSyncReturnValue<StdoutErrorType> {
+    /**
+		The output of the process with `stdout` and `stderr` interleaved.
+
+		This is `undefined` if either:
+		- the `all` option is `false` (default value)
+		- `execa.sync()` was used
+		*/
+    all?: StdoutErrorType;
+    /**
+		Whether the process was canceled.
+		*/
+    isCanceled: boolean;
+  }
+  interface ExecaSyncError<StdoutErrorType = string> extends Error, ExecaReturnBase<StdoutErrorType> {
+    /**
+		Error message when the child process failed to run. In addition to the underlying error message, it also contains some information related to why the child process errored.
+
+		The child process stderr then stdout are appended to the end, separated with newlines and not interleaved.
+		*/
+    message: string;
+    /**
+		This is the same as the `message` property except it does not include the child process stdout/stderr.
+		*/
+    shortMessage: string;
+    /**
+		Original error message. This is the same as the `message` property except it includes neither the child process stdout/stderr nor some additional information added by Execa.
+
+		This is `undefined` unless the child process exited due to an `error` event or a timeout.
+		*/
+    originalMessage?: string;
+  }
+  interface ExecaError<StdoutErrorType = string> extends ExecaSyncError<StdoutErrorType> {
+    /**
+		The output of the process with `stdout` and `stderr` interleaved.
+
+		This is `undefined` if either:
+		- the `all` option is `false` (default value)
+		- `execa.sync()` was used
+		*/
+    all?: StdoutErrorType;
+    /**
+		Whether the process was canceled.
+		*/
+    isCanceled: boolean;
+  }
+  interface KillOptions {
+    /**
+		Milliseconds to wait for the child process to terminate before sending `SIGKILL`.
+
+		Can be disabled with `false`.
+
+		@default 5000
+		*/
+    forceKillAfterTimeout?: number | false;
+  }
+  interface ExecaChildPromise<StdoutErrorType> {
+    /**
+		Stream combining/interleaving [`stdout`](https://nodejs.org/api/child_process.html#child_process_subprocess_stdout) and [`stderr`](https://nodejs.org/api/child_process.html#child_process_subprocess_stderr).
+
+		This is `undefined` if either:
+			- the `all` option is `false` (the default value)
+			- both `stdout` and `stderr` options are set to [`'inherit'`, `'ipc'`, `Stream` or `integer`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio)
+		*/
+    all?: Readable;
+    catch<ResultType = never>(onRejected?: (reason: ExecaError<StdoutErrorType>) => ResultType | PromiseLike<ResultType>): Promise<ExecaReturnValue<StdoutErrorType> | ResultType>;
+    /**
+		Same as the original [`child_process#kill()`](https://nodejs.org/api/child_process.html#child_process_subprocess_kill_signal), except if `signal` is `SIGTERM` (the default value) and the child process is not terminated after 5 seconds, force it by sending `SIGKILL`.
+		*/
+    kill(signal?: string, options?: KillOptions): void;
+    /**
+		Similar to [`childProcess.kill()`](https://nodejs.org/api/child_process.html#child_process_subprocess_kill_signal). This is preferred when cancelling the child process execution as the error is more descriptive and [`childProcessResult.isCanceled`](#iscanceled) is set to `true`.
+		*/
+    cancel(): void;
+  }
+  type ExecaChildProcess<StdoutErrorType = string> = ChildProcess & ExecaChildPromise<StdoutErrorType> & Promise<ExecaReturnValue<StdoutErrorType>>;
+}
+declare const execa: {
+  /**
+	Execute a file.
+
+	Think of this as a mix of `child_process.execFile` and `child_process.spawn`.
+
+	@param file - The program/script to execute.
+	@param arguments - Arguments to pass to `file` on execution.
+	@returns A [`child_process` instance](https://nodejs.org/api/child_process.html#child_process_class_childprocess), which is enhanced to also be a `Promise` for a result `Object` with `stdout` and `stderr` properties.
+
+	@example
+	```
+	import execa = require('execa');
+
+	(async () => {
+		const {stdout} = await execa('echo', ['unicorns']);
+		console.log(stdout);
+		//=> 'unicorns'
+
+		// Cancelling a spawned process
+
+		const subprocess = execa('node');
+
+		setTimeout(() => {
+			subprocess.cancel()
+		}, 1000);
+
+		try {
+			await subprocess;
+		} catch (error) {
+			console.log(subprocess.killed); // true
+			console.log(error.isCanceled); // true
+		}
+	})();
+
+	// Pipe the child process stdout to the current stdout
+	execa('echo', ['unicorns']).stdout.pipe(process.stdout);
+	```
+	*/
+  (file: string, arguments?: readonly string[], options?: execa.Options): execa.ExecaChildProcess;
+  (file: string, arguments?: readonly string[], options?: execa.Options<null>): execa.ExecaChildProcess<Buffer>;
+  (file: string, options?: execa.Options): execa.ExecaChildProcess;
+  (file: string, options?: execa.Options<null>): execa.ExecaChildProcess<Buffer>;
+  /**
+	Execute a file synchronously.
+
+	This method throws an `Error` if the command fails.
+
+	@param file - The program/script to execute.
+	@param arguments - Arguments to pass to `file` on execution.
+	@returns A result `Object` with `stdout` and `stderr` properties.
+	*/
+  sync(file: string, arguments?: readonly string[], options?: execa.SyncOptions): execa.ExecaSyncReturnValue;
+  sync(file: string, arguments?: readonly string[], options?: execa.SyncOptions<null>): execa.ExecaSyncReturnValue<Buffer>;
+  sync(file: string, options?: execa.SyncOptions): execa.ExecaSyncReturnValue;
+  sync(file: string, options?: execa.SyncOptions<null>): execa.ExecaSyncReturnValue<Buffer>;
+  /**
+	Same as `execa()` except both file and arguments are specified in a single `command` string. For example, `execa('echo', ['unicorns'])` is the same as `execa.command('echo unicorns')`.
+
+	If the file or an argument contains spaces, they must be escaped with backslashes. This matters especially if `command` is not a constant but a variable, for example with `__dirname` or `process.cwd()`. Except for spaces, no escaping/quoting is needed.
+
+	The `shell` option must be used if the `command` uses shell-specific features (for example, `&&` or `||`), as opposed to being a simple `file` followed by its `arguments`.
+
+	@param command - The program/script to execute and its arguments.
+	@returns A [`child_process` instance](https://nodejs.org/api/child_process.html#child_process_class_childprocess), which is enhanced to also be a `Promise` for a result `Object` with `stdout` and `stderr` properties.
+
+	@example
+	```
+	import execa = require('execa');
+
+	(async () => {
+		const {stdout} = await execa.command('echo unicorns');
+		console.log(stdout);
+		//=> 'unicorns'
+	})();
+	```
+	*/
+  command(command: string, options?: execa.Options): execa.ExecaChildProcess;
+  command(command: string, options?: execa.Options<null>): execa.ExecaChildProcess<Buffer>;
+  /**
+	Same as `execa.command()` but synchronous.
+
+	@param command - The program/script to execute and its arguments.
+	@returns A result `Object` with `stdout` and `stderr` properties.
+	*/
+  commandSync(command: string, options?: execa.SyncOptions): execa.ExecaSyncReturnValue;
+  commandSync(command: string, options?: execa.SyncOptions<null>): execa.ExecaSyncReturnValue<Buffer>;
+  /**
+	Execute a Node.js script as a child process.
+
+	Same as `execa('node', [scriptPath, ...arguments], options)` except (like [`child_process#fork()`](https://nodejs.org/api/child_process.html#child_process_child_process_fork_modulepath_args_options)):
+		- the current Node version and options are used. This can be overridden using the `nodePath` and `nodeArguments` options.
+		- the `shell` option cannot be used
+		- an extra channel [`ipc`](https://nodejs.org/api/child_process.html#child_process_options_stdio) is passed to [`stdio`](#stdio)
+
+	@param scriptPath - Node.js script to execute.
+	@param arguments - Arguments to pass to `scriptPath` on execution.
+	@returns A [`child_process` instance](https://nodejs.org/api/child_process.html#child_process_class_childprocess), which is enhanced to also be a `Promise` for a result `Object` with `stdout` and `stderr` properties.
+	*/
+  node(scriptPath: string, arguments?: readonly string[], options?: execa.NodeOptions): execa.ExecaChildProcess;
+  node(scriptPath: string, arguments?: readonly string[], options?: execa.Options<null>): execa.ExecaChildProcess<Buffer>;
+  node(scriptPath: string, options?: execa.Options): execa.ExecaChildProcess;
+  node(scriptPath: string, options?: execa.Options<null>): execa.ExecaChildProcess<Buffer>;
+};
+//#endregion
+//#region src/common/cli/cli.d.ts
+type RunOptions = Record<string, unknown>;
+interface CliResult extends Promise<unknown> {
+  toObservable(opt?: RunOptions): Observable<string>;
+  toStream(opt?: RunOptions): execa.ExecaChildProcess<string>;
+  cwd(cwd: string): CliResult;
+  sync(opt?: RunOptions): execa.ExecaSyncReturnValue<string>;
+  getRaw(opt?: RunOptions): string;
+  get(opt?: RunOptions): string;
+}
+declare class Cli {
+  cmd: string;
+  constructor(cmd: string);
+  sync(...args: string[]): execa.ExecaSyncReturnValue<string>;
+  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): undefined<string>;
+  pm(...args: string[]): undefined<string>;
+  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[]): undefined<string>;
+  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[]): undefined<string>;
+  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[]): undefined<string>;
+  reset(...args: string[]): undefined<string>;
+  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): undefined<string>;
+  version(...args: string[]): undefined<string>;
+  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): undefined<string>;
+  version(...args: string[]): undefined<string>;
+  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): undefined<string>;
+  version(...args: string[]): undefined<string>;
+  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): undefined<string>;
+  version(...args: string[]): undefined<string>;
+  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
+declare function getPackageManager(pkgManager: string): {
+  newVersion(version: string): undefined<string>;
+  pm(...args: string[]): undefined<string>;
+  run(...args: string[]): CliResult;
+  install(...args: string[]): CliResult;
+  restore(): CliResult;
+  cmd: string;
+  sync(...args: string[]): undefined<string>;
+  get(...args: string[]): string;
+} | {
+  cmd: string;
+  newVersion(version: string): undefined<string>;
+  version(...args: string[]): undefined<string>;
+  run(...args: string[]): CliResult;
+  install(...args: string[]): CliResult;
+  publish(...args: string[]): CliResult;
+  pack(...args: string[]): CliResult;
+  restore(): CliResult;
+  sync(...args: string[]): undefined<string>;
+  get(...args: string[]): string;
+} | {
+  newVersion(version: string): undefined<string>;
+  version(...args: string[]): undefined<string>;
+  run(...args: string[]): CliResult;
+  install(...args: string[]): CliResult;
+  restore(): CliResult;
+  cmd: string;
+  sync(...args: string[]): undefined<string>;
+  get(...args: string[]): string;
+} | {
+  newVersion(version: string): undefined<string>;
+  version(...args: string[]): undefined<string>;
+  run(...args: string[]): CliResult;
+  install(...args: string[]): CliResult;
+  restore(): CliResult;
+  cmd: string;
+  sync(...args: string[]): undefined<string>;
+  get(...args: string[]): string;
+};
+//#endregion
+//#region src/common/run-command.d.ts
+declare function runCommand(klass: CommandConstructor, opts: Record<string, any>): Promise<void>;
+//#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/semantic/define-config.d.ts
+/**
+ * Define the semantic-release configuration based on the ClubMed API configuration.
+ * @param {import('semantic-release').GlobalConfig} opts
+ * @returns {import('semantic-release').GlobalConfig}
+ */
+declare function defineConfig(opts?: {}): {
+  noCi: boolean;
+  branches: ({
+    name: string;
+    channel: string;
+    prerelease?: undefined;
+  } | {
+    name: string | undefined;
+    channel: string;
+    prerelease: boolean;
+  })[];
+  verifyConditions: string[];
+  analyzeCommits: string[];
+  verifyRelease: string[];
+  generateNotes: string[];
+  prepare: string[];
+  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;
+  })[];
+  parserOpts: {
+    noteKeywords: string[];
+  };
+  writerOpts: {
+    transform: typeof transformWriter;
+  };
+};
+//#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/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, 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