@datadog/datadog-ci 5.12.0 → 5.13.0

package/dist/bundle.d.ts

@@ -0,0 +1,2904 @@
+/// <reference types="node" />
+import * as stream from "stream";
+import { Duplex, Readable, Writable } from "stream";
+import { URL as URL$1, URLSearchParams } from "node:url";
+import { Duplex as Duplex$1, Readable as Readable$1, Writable as Writable$1 } from "node:stream";
+import { EventEmitter } from "node:events";
+import { Blob, File } from "node:buffer";
+import { ConnectionOptions, TLSSocket } from "node:tls";
+import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from "node:net";
+import * as http from "http";
+import http_, { OutgoingHttpHeaders } from "http";
+import * as net from "net";
+import * as tls from "tls";
+import { ConnectionOptions as ConnectionOptions$1 } from "tls";
+import https from "https";
+import { Stats, createReadStream } from "fs";
+import { Context } from "vm";
+
+//#region \0rolldown/runtime.js
+//#endregion
+//#region ../../node_modules/typanion/lib/types.d.ts
+declare type BoundCoercionFn = () => BoundCoercionFn;
+declare type CoercionFn = (v: any) => BoundCoercionFn;
+declare type Coercion = [string, BoundCoercionFn];
+declare type LooseTest<U> = (value: U, test?: ValidationState) => boolean;
+declare type ValidationState = {
+  p?: string;
+  errors?: string[];
+  coercions?: Coercion[];
+  coercion?: CoercionFn;
+};
+//#endregion
+//#region ../../node_modules/clipanion/lib/core.d.ts
+declare type StateMachine = {
+  nodes: Array<Node>;
+};
+declare type RunState = {
+  candidateUsage: string | null;
+  requiredOptions: Array<Array<string>>;
+  errorMessage: string | null;
+  ignoreOptions: boolean;
+  options: Array<{
+    name: string;
+    value: any;
+  }>;
+  path: Array<string>;
+  positionals: Array<{
+    value: string;
+    extra: boolean | typeof NoLimits;
+  }>;
+  remainder: string | null;
+  selectedIndex: number | null;
+};
+declare type Transition = {
+  to: number;
+  reducer?: Callback<keyof typeof reducers, typeof reducers>;
+};
+declare type Node = {
+  dynamics: Array<[Callback<keyof typeof tests, typeof tests>, Transition]>;
+  shortcuts: Array<Transition>;
+  statics: {
+    [segment: string]: Array<Transition>;
+  };
+};
+declare type UndefinedKeys<T> = { [P in keyof T]-?: undefined extends T[P] ? P : never }[keyof T];
+declare type UndefinedTupleKeys<T extends Array<unknown>> = UndefinedKeys<Omit<T, keyof []>>;
+declare type TupleKeys<T> = Exclude<keyof T, keyof []>;
+declare type CallbackFn<P extends Array<any>, R> = (state: RunState, segment: string, ...args: P) => R;
+declare type CallbackFnParameters<T extends CallbackFn<any, any>> = T extends ((state: RunState, segment: string, ...args: infer P) => any) ? P : never;
+declare type CallbackStore<T extends string, R> = Record<T, CallbackFn<any, R>>;
+declare type Callback<T extends string, S extends CallbackStore<T, any>> = [TupleKeys<CallbackFnParameters<S[T]>>] extends [UndefinedTupleKeys<CallbackFnParameters<S[T]>>] ? (T | [T, ...CallbackFnParameters<S[T]>]) : [T, ...CallbackFnParameters<S[T]>];
+declare const tests: {
+  always: () => boolean;
+  isOptionLike: (state: RunState, segment: string) => boolean;
+  isNotOptionLike: (state: RunState, segment: string) => boolean;
+  isOption: (state: RunState, segment: string, name: string, hidden?: boolean) => boolean;
+  isBatchOption: (state: RunState, segment: string, names: Array<string>) => boolean;
+  isBoundOption: (state: RunState, segment: string, names: Array<string>, options: Array<OptDefinition>) => boolean;
+  isNegatedOption: (state: RunState, segment: string, name: string) => boolean;
+  isHelp: (state: RunState, segment: string) => boolean;
+  isUnsupportedOption: (state: RunState, segment: string, names: Array<string>) => boolean;
+  isInvalidOption: (state: RunState, segment: string) => boolean;
+};
+declare const reducers: {
+  setCandidateState: (state: RunState, segment: string, candidateState: Partial<RunState>) => {
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    errorMessage: string | null;
+    ignoreOptions: boolean;
+    options: Array<{
+      name: string;
+      value: any;
+    }>;
+    path: Array<string>;
+    positionals: Array<{
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+  setSelectedIndex: (state: RunState, segment: string, index: number) => {
+    selectedIndex: number;
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    errorMessage: string | null;
+    ignoreOptions: boolean;
+    options: Array<{
+      name: string;
+      value: any;
+    }>;
+    path: Array<string>;
+    positionals: Array<{
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }>;
+    remainder: string | null;
+  };
+  pushBatch: (state: RunState, segment: string) => {
+    options: {
+      name: string;
+      value: any;
+    }[];
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    errorMessage: string | null;
+    ignoreOptions: boolean;
+    path: Array<string>;
+    positionals: Array<{
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+  pushBound: (state: RunState, segment: string) => {
+    options: {
+      name: string;
+      value: any;
+    }[];
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    errorMessage: string | null;
+    ignoreOptions: boolean;
+    path: Array<string>;
+    positionals: Array<{
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+  pushPath: (state: RunState, segment: string) => {
+    path: string[];
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    errorMessage: string | null;
+    ignoreOptions: boolean;
+    options: Array<{
+      name: string;
+      value: any;
+    }>;
+    positionals: Array<{
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+  pushPositional: (state: RunState, segment: string) => {
+    positionals: {
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }[];
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    errorMessage: string | null;
+    ignoreOptions: boolean;
+    options: Array<{
+      name: string;
+      value: any;
+    }>;
+    path: Array<string>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+  pushExtra: (state: RunState, segment: string) => {
+    positionals: {
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }[];
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    errorMessage: string | null;
+    ignoreOptions: boolean;
+    options: Array<{
+      name: string;
+      value: any;
+    }>;
+    path: Array<string>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+  pushExtraNoLimits: (state: RunState, segment: string) => {
+    positionals: {
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }[];
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    errorMessage: string | null;
+    ignoreOptions: boolean;
+    options: Array<{
+      name: string;
+      value: any;
+    }>;
+    path: Array<string>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+  pushTrue: (state: RunState, segment: string, name?: string) => {
+    options: {
+      name: string;
+      value: any;
+    }[];
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    errorMessage: string | null;
+    ignoreOptions: boolean;
+    path: Array<string>;
+    positionals: Array<{
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+  pushFalse: (state: RunState, segment: string, name?: string) => {
+    options: {
+      name: string;
+      value: any;
+    }[];
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    errorMessage: string | null;
+    ignoreOptions: boolean;
+    path: Array<string>;
+    positionals: Array<{
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+  pushUndefined: (state: RunState, segment: string) => {
+    options: {
+      name: string;
+      value: any;
+    }[];
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    errorMessage: string | null;
+    ignoreOptions: boolean;
+    path: Array<string>;
+    positionals: Array<{
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+  pushStringValue: (state: RunState, segment: string) => {
+    options: {
+      name: string;
+      value: any;
+    }[];
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    errorMessage: string | null;
+    ignoreOptions: boolean;
+    path: Array<string>;
+    positionals: Array<{
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+  setStringValue: (state: RunState, segment: string) => {
+    options: {
+      name: string;
+      value: any;
+    }[];
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    errorMessage: string | null;
+    ignoreOptions: boolean;
+    path: Array<string>;
+    positionals: Array<{
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+  inhibateOptions: (state: RunState) => {
+    ignoreOptions: boolean;
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    errorMessage: string | null;
+    options: Array<{
+      name: string;
+      value: any;
+    }>;
+    path: Array<string>;
+    positionals: Array<{
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+  useHelp: (state: RunState, segment: string, command: number) => {
+    options: {
+      name: string;
+      value: string;
+    }[];
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    errorMessage: string | null;
+    ignoreOptions: boolean;
+    path: Array<string>;
+    positionals: Array<{
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+  setError: (state: RunState, segment: string, errorMessage: string) => {
+    errorMessage: string;
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    ignoreOptions: boolean;
+    options: Array<{
+      name: string;
+      value: any;
+    }>;
+    path: Array<string>;
+    positionals: Array<{
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+  setOptionArityError: (state: RunState, segment: string) => {
+    errorMessage: string;
+    candidateUsage: string | null;
+    requiredOptions: Array<Array<string>>;
+    ignoreOptions: boolean;
+    options: Array<{
+      name: string;
+      value: any;
+    }>;
+    path: Array<string>;
+    positionals: Array<{
+      value: string;
+      extra: boolean | typeof NoLimits;
+    }>;
+    remainder: string | null;
+    selectedIndex: number | null;
+  };
+};
+declare const NoLimits: unique symbol;
+declare type ArityDefinition = {
+  leading: Array<string>;
+  extra: Array<string> | typeof NoLimits;
+  trailing: Array<string>;
+  proxy: boolean;
+};
+declare type OptDefinition = {
+  names: Array<string>;
+  description?: string;
+  arity: number;
+  hidden: boolean;
+  required: boolean;
+  allowBinding: boolean;
+};
+declare class CommandBuilder<Context> {
+  readonly cliIndex: number;
+  readonly cliOpts: Readonly<CliOptions$1>;
+  readonly allOptionNames: Array<string>;
+  readonly arity: ArityDefinition;
+  readonly options: Array<OptDefinition>;
+  readonly paths: Array<Array<string>>;
+  private context?;
+  constructor(cliIndex: number, cliOpts: CliOptions$1);
+  addPath(path: Array<string>): void;
+  setArity({
+    leading,
+    trailing,
+    extra,
+    proxy
+  }: Partial<ArityDefinition>): void;
+  addPositional({
+    name,
+    required
+  }?: {
+    name?: string;
+    required?: boolean;
+  }): void;
+  addRest({
+    name,
+    required
+  }?: {
+    name?: string;
+    required?: number;
+  }): void;
+  addProxy({
+    required
+  }?: {
+    name?: string;
+    required?: number;
+  }): void;
+  addOption({
+    names,
+    description,
+    arity,
+    hidden,
+    required,
+    allowBinding
+  }: Partial<OptDefinition> & {
+    names: Array<string>;
+  }): void;
+  setContext(context: Context): void;
+  usage({
+    detailed,
+    inlineOptions
+  }?: {
+    detailed?: boolean;
+    inlineOptions?: boolean;
+  }): {
+    usage: string;
+    options: {
+      definition: string;
+      description: string;
+      required: boolean;
+    }[];
+  };
+  compile(): {
+    machine: StateMachine;
+    context: Context;
+  };
+  private registerOptions;
+}
+declare type CliOptions$1 = {
+  binaryName: string;
+};
+//#endregion
+//#region ../../node_modules/clipanion/lib/format.d.ts
+interface ColorFormat {
+  header(str: string): string;
+  bold(str: string): string;
+  error(str: string): string;
+  code(str: string): string;
+}
+//#endregion
+//#region ../../node_modules/clipanion/lib/advanced/options/utils.d.ts
+declare const isOptionSymbol: unique symbol;
+declare type CommandOption<T> = {
+  [isOptionSymbol]: true;
+  definition: <Context extends BaseContext>(builder: CommandBuilder<CliContext<Context>>, key: string) => void;
+  transformer: <Context extends BaseContext>(builder: CommandBuilder<CliContext<Context>>, key: string, state: RunState, context: Context) => T;
+};
+//#endregion
+//#region ../../node_modules/clipanion/lib/advanced/Cli.d.ts
+declare type MakeOptional<T, Keys extends keyof T> = Omit<T, Keys> & Partial<Pick<T, Keys>>;
+declare type VoidIfEmpty<T> = keyof T extends never ? void : never;
+/**
+ * The base context of the CLI.
+ *
+ * All Contexts have to extend it.
+ */
+declare type BaseContext = {
+  /**
+   * Environment variables.
+   *
+   * @default
+   * process.env
+   */
+  env: Record<string, string | undefined>;
+  /**
+   * The input stream of the CLI.
+   *
+   * @default
+   * process.stdin
+   */
+  stdin: Readable;
+  /**
+   * The output stream of the CLI.
+   *
+   * @default
+   * process.stdout
+   */
+  stdout: Writable;
+  /**
+   * The error stream of the CLI.
+   *
+   * @default
+   * process.stderr
+   */
+  stderr: Writable;
+  /**
+   * Whether colors should be enabled.
+   */
+  colorDepth: number;
+};
+declare type CliContext<Context extends BaseContext> = {
+  commandClass: CommandClass<Context>;
+};
+declare type RunCommand<Context extends BaseContext = BaseContext> = Array<CommandClass<Context>> | CommandClass<Context>;
+declare type CliOptions = Readonly<{
+  /**
+   * The label of the binary.
+   *
+   * Shown at the top of the usage information.
+   */
+  binaryLabel?: string;
+  /**
+   * The name of the binary.
+   *
+   * Included in the path and the examples of the definitions.
+   */
+  binaryName: string;
+  /**
+   * The version of the binary.
+   *
+   * Shown at the top of the usage information.
+   */
+  binaryVersion?: string;
+  /**
+   * If `true`, the Cli will hook into the process standard streams to catch
+   * the output produced by console.log and redirect them into the context
+   * streams. Note: stdin isn't captured at the moment.
+   *
+   * @default
+   * false
+   */
+  enableCapture: boolean;
+  /**
+   * If `true`, the Cli will use colors in the output. If `false`, it won't.
+   * If `undefined`, Clipanion will infer the correct value from the env.
+   */
+  enableColors?: boolean;
+}>;
+declare type MiniCli<Context extends BaseContext> = CliOptions & {
+  /**
+   * Returns an Array representing the definitions of all registered commands.
+   */
+  definitions(): Array<Definition>;
+  /**
+   * Formats errors using colors.
+   *
+   * @param error The error to format. If `error.name` is `'Error'`, it is replaced with `'Internal Error'`.
+   * @param opts.command The command whose usage will be included in the formatted error.
+   */
+  error(error: Error, opts?: {
+    command?: Command<Context> | null;
+  }): string;
+  /**
+   * Returns a rich color format if colors are enabled, or a plain text format otherwise.
+   *
+   * @param colored Forcefully enable or disable colors.
+   */
+  format(colored?: boolean): ColorFormat;
+  /**
+   * Compiles a command and its arguments using the `CommandBuilder`.
+   *
+   * @param input An array containing the name of the command and its arguments
+   *
+   * @returns The compiled `Command`, with its properties populated with the arguments.
+   */
+  process(input: Array<string>, context?: Partial<Context>): Command<Context>;
+  /**
+   * Runs a command.
+   *
+   * @param input An array containing the name of the command and its arguments
+   * @param context Overrides the Context of the main `Cli` instance
+   *
+   * @returns The exit code of the command
+   */
+  run(input: Array<string>, context?: Partial<Context>): Promise<number>;
+  /**
+   * Returns the usage of a command.
+   *
+   * @param command The `Command` whose usage will be returned or `null` to return the usage of all commands.
+   * @param opts.detailed If `true`, the usage of a command will also include its description, details, and examples. Doesn't have any effect if `command` is `null` or doesn't have a `usage` property.
+   * @param opts.prefix The prefix displayed before each command. Defaults to `$`.
+   */
+  usage(command?: CommandClass<Context> | Command<Context> | null, opts?: {
+    detailed?: boolean;
+    prefix?: string;
+  }): string;
+};
+/**
+ * @template Context The context shared by all commands. Contexts are a set of values, defined when calling the `run`/`runExit` functions from the CLI instance, that will be made available to the commands via `this.context`.
+ */
+declare class Cli<Context extends BaseContext = BaseContext> implements Omit<MiniCli<Context>, `process` | `run`> {
+  /**
+   * The default context of the CLI.
+   *
+   * Contains the stdio of the current `process`.
+   */
+  static defaultContext: {
+    env: NodeJS.ProcessEnv;
+    stdin: NodeJS.ReadStream & {
+      fd: 0;
+    };
+    stdout: NodeJS.WriteStream & {
+      fd: 1;
+    };
+    stderr: NodeJS.WriteStream & {
+      fd: 2;
+    };
+    colorDepth: number;
+  };
+  private readonly builder;
+  protected readonly registrations: Map<CommandClass<Context>, {
+    index: number;
+    builder: CommandBuilder<CliContext<Context>>;
+    specs: Map<string, CommandOption<unknown>>;
+  }>;
+  readonly binaryLabel?: string;
+  readonly binaryName: string;
+  readonly binaryVersion?: string;
+  readonly enableCapture: boolean;
+  readonly enableColors?: boolean;
+  /**
+   * Creates a new Cli and registers all commands passed as parameters.
+   *
+   * @param commandClasses The Commands to register
+   * @returns The created `Cli` instance
+   */
+  static from<Context extends BaseContext = BaseContext>(commandClasses: RunCommand<Context>, options?: Partial<CliOptions>): Cli<Context>;
+  constructor({
+    binaryLabel,
+    binaryName: binaryNameOpt,
+    binaryVersion,
+    enableCapture,
+    enableColors
+  }?: Partial<CliOptions>);
+  /**
+   * Registers a command inside the CLI.
+   */
+  register(commandClass: CommandClass<Context>): void;
+  process(input: Array<string>, context: VoidIfEmpty<Omit<Context, keyof BaseContext>>): Command<Context>;
+  process(input: Array<string>, context: MakeOptional<Context, keyof BaseContext>): Command<Context>;
+  run(input: Command<Context> | Array<string>, context: VoidIfEmpty<Omit<Context, keyof BaseContext>>): Promise<number>;
+  run(input: Command<Context> | Array<string>, context: MakeOptional<Context, keyof BaseContext>): Promise<number>;
+  /**
+   * Runs a command and exits the current `process` with the exit code returned by the command.
+   *
+   * @param input An array containing the name of the command and its arguments.
+   *
+   * @example
+   * cli.runExit(process.argv.slice(2))
+   */
+  runExit(input: Command<Context> | Array<string>, context: VoidIfEmpty<Omit<Context, keyof BaseContext>>): Promise<void>;
+  runExit(input: Command<Context> | Array<string>, context: MakeOptional<Context, keyof BaseContext>): Promise<void>;
+  suggest(input: Array<string>, partial: boolean): string[][];
+  definitions({
+    colored
+  }?: {
+    colored?: boolean;
+  }): Array<Definition>;
+  usage(command?: CommandClass<Context> | Command<Context> | null, {
+    colored,
+    detailed,
+    prefix
+  }?: {
+    colored?: boolean;
+    detailed?: boolean;
+    prefix?: string;
+  }): string;
+  error(error: Error | any, {
+    colored,
+    command
+  }?: {
+    colored?: boolean;
+    command?: Command<Context> | null;
+  }): string;
+  format(colored?: boolean): ColorFormat;
+  protected getUsageByRegistration(klass: CommandClass<Context>, opts?: {
+    detailed?: boolean;
+    inlineOptions?: boolean;
+  }): {
+    usage: string;
+    options: {
+      definition: string;
+      description: string;
+      required: boolean;
+    }[];
+  };
+  protected getUsageByIndex(n: number, opts?: {
+    detailed?: boolean;
+    inlineOptions?: boolean;
+  }): {
+    usage: string;
+    options: {
+      definition: string;
+      description: string;
+      required: boolean;
+    }[];
+  };
+}
+//#endregion
+//#region ../../node_modules/clipanion/lib/advanced/Command.d.ts
+/**
+ * The usage of a Command.
+ */
+declare type Usage = {
+  /**
+   * The category of the command.
+   *
+   * Included in the detailed usage.
+   */
+  category?: string;
+  /**
+   * The short description of the command, formatted as Markdown.
+   *
+   * Included in the detailed usage.
+   */
+  description?: string;
+  /**
+   * The extended details of the command, formatted as Markdown.
+   *
+   * Included in the detailed usage.
+   */
+  details?: string;
+  /**
+   * Examples of the command represented as an Array of tuples.
+   *
+   * The first element of the tuple represents the description of the example.
+   *
+   * The second element of the tuple represents the command of the example.
+   * If present, the leading `$0` is replaced with `cli.binaryName`.
+   */
+  examples?: Array<[string, string]>;
+};
+/**
+ * The definition of a Command.
+ */
+declare type Definition = Usage & {
+  /**
+   * The path of the command, starting with `cli.binaryName`.
+   */
+  path: string;
+  /**
+   * The detailed usage of the command.
+   */
+  usage: string;
+  /**
+   * The various options registered on the command.
+   */
+  options: Array<{
+    definition: string;
+    description?: string;
+    required: boolean;
+  }>;
+};
+declare type CommandClass<Context extends BaseContext = BaseContext> = {
+  new (): Command<Context>;
+  paths?: Array<Array<string>>;
+  schema?: Array<LooseTest<{
+    [key: string]: unknown;
+  }>>;
+  usage?: Usage;
+};
+/**
+ * Base abstract class for CLI commands. The main thing to remember is to
+ * declare an async `execute` member function that will be called when the
+ * command is invoked from the CLI, and optionally a `paths` property to
+ * declare the set of paths under which the command should be exposed.
+ */
+declare abstract class Command<Context extends BaseContext = BaseContext> {
+  /**
+   * @deprecated Do not use this; prefer the static `paths` property instead.
+   */
+  paths?: undefined;
+  /**
+   * Defined to prevent a common typo.
+   */
+  static path: never;
+  /**
+   * Paths under which the command should be exposed.
+   */
+  static paths?: Array<Array<string>>;
+  /**
+   * Defines the usage information for the given command.
+   */
+  static Usage(usage: Usage): Usage;
+  /**
+   * Contains the usage information for the command. If undefined, the
+   * command will be hidden from the general listing.
+   */
+  static usage?: Usage;
+  /**
+   * Defines a schema to apply before running the `execute` method. The
+   * schema is expected to be generated by Typanion.
+   *
+   * @see https://github.com/arcanis/typanion
+   */
+  static schema?: Array<LooseTest<{
+    [key: string]: unknown;
+  }>>;
+  /**
+   * Standard function that'll get executed by `Cli#run` and `Cli#runExit`.
+   *
+   * Expected to return an exit code or nothing (which Clipanion will treat
+   * as if 0 had been returned).
+   */
+  abstract execute(): Promise<number | void>;
+  /**
+   * Standard error handler which will simply rethrow the error. Can be used
+   * to add custom logic to handle errors from the command or simply return
+   * the parent class error handling.
+   */
+  catch(error: any): Promise<void>;
+  /**
+   * Predefined that will be set to true if `-h,--help` has been used, in
+   * which case `Command#execute` won't be called.
+   */
+  help: boolean;
+  /**
+   * Predefined variable that will be populated with a miniature API that can
+   * be used to query Clipanion and forward commands.
+   */
+  cli: MiniCli<Context>;
+  /**
+   * Predefined variable that will be populated with the context of the
+   * application.
+   */
+  context: Context;
+  /**
+   * Predefined variable that will be populated with the path that got used
+   * to access the command currently being executed.
+   */
+  path: Array<string>;
+  validateAndExecute(): Promise<number>;
+  /**
+   * Used to detect option definitions.
+   */
+  static isOption: typeof isOptionSymbol;
+  /**
+   * Just an helper to use along with the `paths` fields, to make it
+   * clearer that a command is the default one.
+   *
+   * @example
+   * class MyCommand extends Command {
+   *   static paths = [Command.Default];
+   * }
+   */
+  static Default: never[];
+}
+//#endregion
+//#region ../base/dist/index.d.ts
+type CommandContext = BaseContext & {
+  builtinPlugins: string[];
+};
+//#endregion
+//#region ../base/dist/helpers/apikey.d.ts
+/** ApiKeyValidator is an helper interface to interpret Datadog error responses and possibly check the
+ * validity of the api key.
+ */
+interface ApiKeyValidator {
+  verifyApiKey(error: unknown): Promise<void>;
+  validateApiKey(): Promise<boolean>;
+}
+//#endregion
+//#region ../../node_modules/undici/types/utility.d.ts
+type AutocompletePrimitiveBaseType<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : never;
+type Autocomplete<T> = T | (AutocompletePrimitiveBaseType<T> & Record<never, never>);
+//#endregion
+//#region ../../node_modules/undici/types/header.d.ts
+/**
+ * The header type declaration of `undici`.
+ */
+type IncomingHttpHeaders = Record<string, string | string[] | undefined>;
+type HeaderNames = Autocomplete<'Accept' | 'Accept-CH' | 'Accept-Charset' | 'Accept-Encoding' | 'Accept-Language' | 'Accept-Patch' | 'Accept-Post' | 'Accept-Ranges' | 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Access-Control-Request-Headers' | 'Access-Control-Request-Method' | 'Age' | 'Allow' | 'Alt-Svc' | 'Alt-Used' | 'Authorization' | 'Cache-Control' | 'Clear-Site-Data' | 'Connection' | 'Content-Disposition' | 'Content-Encoding' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-Range' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Type' | 'Cookie' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Resource-Policy' | 'Date' | 'Device-Memory' | 'ETag' | 'Expect' | 'Expect-CT' | 'Expires' | 'Forwarded' | 'From' | 'Host' | 'If-Match' | 'If-Modified-Since' | 'If-None-Match' | 'If-Range' | 'If-Unmodified-Since' | 'Keep-Alive' | 'Last-Modified' | 'Link' | 'Location' | 'Max-Forwards' | 'Origin' | 'Permissions-Policy' | 'Priority' | 'Proxy-Authenticate' | 'Proxy-Authorization' | 'Range' | 'Referer' | 'Referrer-Policy' | 'Retry-After' | 'Sec-Fetch-Dest' | 'Sec-Fetch-Mode' | 'Sec-Fetch-Site' | 'Sec-Fetch-User' | 'Sec-Purpose' | 'Sec-WebSocket-Accept' | 'Server' | 'Server-Timing' | 'Service-Worker-Navigation-Preload' | 'Set-Cookie' | 'SourceMap' | 'Strict-Transport-Security' | 'TE' | 'Timing-Allow-Origin' | 'Trailer' | 'Transfer-Encoding' | 'Upgrade' | 'Upgrade-Insecure-Requests' | 'User-Agent' | 'Vary' | 'Via' | 'WWW-Authenticate' | 'X-Content-Type-Options' | 'X-Frame-Options'>;
+type IANARegisteredMimeType = Autocomplete<'audio/aac' | 'video/x-msvideo' | 'image/avif' | 'video/av1' | 'application/octet-stream' | 'image/bmp' | 'text/css' | 'text/csv' | 'application/vnd.ms-fontobject' | 'application/epub+zip' | 'image/gif' | 'application/gzip' | 'text/html' | 'image/x-icon' | 'text/calendar' | 'image/jpeg' | 'text/javascript' | 'application/json' | 'application/ld+json' | 'audio/x-midi' | 'audio/mpeg' | 'video/mp4' | 'video/mpeg' | 'audio/ogg' | 'video/ogg' | 'application/ogg' | 'audio/opus' | 'font/otf' | 'application/pdf' | 'image/png' | 'application/rtf' | 'image/svg+xml' | 'image/tiff' | 'video/mp2t' | 'font/ttf' | 'text/plain' | 'application/wasm' | 'video/webm' | 'audio/webm' | 'image/webp' | 'font/woff' | 'font/woff2' | 'application/xhtml+xml' | 'application/xml' | 'application/zip' | 'video/3gpp' | 'video/3gpp2' | 'model/gltf+json' | 'model/gltf-binary'>;
+type KnownHeaderValues = {
+  'content-type': IANARegisteredMimeType;
+};
+type HeaderRecord = { [K in HeaderNames | Lowercase<HeaderNames>]?: Lowercase<K> extends keyof KnownHeaderValues ? KnownHeaderValues[Lowercase<K>] : string };
+//#endregion
+//#region ../../node_modules/undici/types/readable.d.ts
+declare class BodyReadable extends Readable$1 {
+  constructor(opts: {
+    resume: (this: Readable$1, size: number) => void | null;
+    abort: () => void | null;
+    contentType?: string;
+    contentLength?: number;
+    highWaterMark?: number;
+  });
+  /** Consumes and returns the body as a string
+   *  https://fetch.spec.whatwg.org/#dom-body-text
+   */
+  text(): Promise<string>;
+  /** Consumes and returns the body as a JavaScript Object
+   *  https://fetch.spec.whatwg.org/#dom-body-json
+   */
+  json(): Promise<unknown>;
+  /** Consumes and returns the body as a Blob
+   *  https://fetch.spec.whatwg.org/#dom-body-blob
+   */
+  blob(): Promise<Blob>;
+  /** Consumes and returns the body as an Uint8Array
+   *  https://fetch.spec.whatwg.org/#dom-body-bytes
+   */
+  bytes(): Promise<Uint8Array>;
+  /** Consumes and returns the body as an ArrayBuffer
+   *  https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+   */
+  arrayBuffer(): Promise<ArrayBuffer>;
+  /** Not implemented
+   *
+   *  https://fetch.spec.whatwg.org/#dom-body-formdata
+   */
+  formData(): Promise<never>;
+  /** Returns true if the body is not null and the body has been consumed
+   *
+   *  Otherwise, returns false
+   *
+   * https://fetch.spec.whatwg.org/#dom-body-bodyused
+   */
+  readonly bodyUsed: boolean;
+  /**
+   * If body is null, it should return null as the body
+   *
+   *  If body is not null, should return the body as a ReadableStream
+   *
+   *  https://fetch.spec.whatwg.org/#dom-body-body
+   */
+  readonly body: never | undefined;
+  /** Dumps the response body by reading `limit` number of bytes.
+   * @param opts.limit Number of bytes to read (optional) - Default: 131072
+   * @param opts.signal AbortSignal to cancel the operation (optional)
+   */
+  dump(opts?: {
+    limit: number;
+    signal?: AbortSignal;
+  }): Promise<void>;
+}
+//#endregion
+//#region ../../node_modules/undici/types/fetch.d.ts
+type BodyInit = ArrayBuffer | AsyncIterable<Uint8Array> | Blob | FormData$1 | Iterable<Uint8Array> | NodeJS.ArrayBufferView | URLSearchParams | null | string;
+interface SpecIterator<T, TReturn = any, TNext = undefined> {
+  next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
+}
+interface SpecIterableIterator<T> extends SpecIterator<T> {
+  [Symbol.iterator](): SpecIterableIterator<T>;
+}
+interface SpecIterable<T> {
+  [Symbol.iterator](): SpecIterator<T>;
+}
+type HeadersInit = [string, string][] | HeaderRecord | Headers$1;
+declare class Headers$1 implements SpecIterable<[string, string]> {
+  constructor(init?: HeadersInit);
+  readonly append: (name: string, value: string) => void;
+  readonly delete: (name: string) => void;
+  readonly get: (name: string) => string | null;
+  readonly has: (name: string) => boolean;
+  readonly set: (name: string, value: string) => void;
+  readonly getSetCookie: () => string[];
+  readonly forEach: (callbackfn: (value: string, key: string, iterable: Headers$1) => void, thisArg?: unknown) => void;
+  readonly keys: () => SpecIterableIterator<string>;
+  readonly values: () => SpecIterableIterator<string>;
+  readonly entries: () => SpecIterableIterator<[string, string]>;
+  readonly [Symbol.iterator]: () => SpecIterableIterator<[string, string]>;
+}
+//#endregion
+//#region ../../node_modules/undici/types/formdata.d.ts
+/**
+ * A `string` or `File` that represents a single value from a set of `FormData` key-value pairs.
+ */
+declare type FormDataEntryValue = string | File;
+/**
+ * Provides a way to easily construct a set of key/value pairs representing form fields and their values, which can then be easily sent using fetch().
+ */
+declare class FormData$1 {
+  /**
+   * Appends a new value onto an existing key inside a FormData object,
+   * or adds the key if it does not already exist.
+   *
+   * The difference between `set()` and `append()` is that if the specified key already exists, `set()` will overwrite all existing values with the new one, whereas `append()` will append the new value onto the end of the existing set of values.
+   *
+   * @param name The name of the field whose data is contained in `value`.
+   * @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
+    or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
+   * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
+   */
+  append(name: string, value: unknown, fileName?: string): void;
+  /**
+   * Set a new value for an existing key inside FormData,
+   * or add the new field if it does not already exist.
+   *
+   * @param name The name of the field whose data is contained in `value`.
+   * @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
+    or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
+   * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
+   *
+   */
+  set(name: string, value: unknown, fileName?: string): void;
+  /**
+   * Returns the first value associated with a given key from within a `FormData` object.
+   * If you expect multiple values and want all of them, use the `getAll()` method instead.
+   *
+   * @param {string} name A name of the value you want to retrieve.
+   *
+   * @returns A `FormDataEntryValue` containing the value. If the key doesn't exist, the method returns null.
+   */
+  get(name: string): FormDataEntryValue | null;
+  /**
+   * Returns all the values associated with a given key from within a `FormData` object.
+   *
+   * @param {string} name A name of the value you want to retrieve.
+   *
+   * @returns An array of `FormDataEntryValue` whose key matches the value passed in the `name` parameter. If the key doesn't exist, the method returns an empty list.
+   */
+  getAll(name: string): FormDataEntryValue[];
+  /**
+   * Returns a boolean stating whether a `FormData` object contains a certain key.
+   *
+   * @param name A string representing the name of the key you want to test for.
+   *
+   * @return A boolean value.
+   */
+  has(name: string): boolean;
+  /**
+   * Deletes a key and its value(s) from a `FormData` object.
+   *
+   * @param name The name of the key you want to delete.
+   */
+  delete(name: string): void;
+  /**
+   * Executes given callback function for each field of the FormData instance
+   */
+  forEach: (callbackfn: (value: FormDataEntryValue, key: string, iterable: FormData$1) => void, thisArg?: unknown) => void;
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all keys contained in this `FormData` object.
+   * Each key is a `string`.
+   */
+  keys: () => SpecIterableIterator<string>;
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all values contained in this object `FormData` object.
+   * Each value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
+   */
+  values: () => SpecIterableIterator<FormDataEntryValue>;
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through the `FormData` key/value pairs.
+   * The key of each pair is a string; the value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
+   */
+  entries: () => SpecIterableIterator<[string, FormDataEntryValue]>;
+  /**
+   * An alias for FormData#entries()
+   */
+  [Symbol.iterator]: () => SpecIterableIterator<[string, FormDataEntryValue]>;
+  readonly [Symbol.toStringTag]: string;
+}
+//#endregion
+//#region ../../node_modules/undici/types/connector.d.ts
+declare function buildConnector(options?: buildConnector.BuildOptions): buildConnector.connector;
+declare namespace buildConnector {
+  export type BuildOptions = (ConnectionOptions | TcpNetConnectOpts | IpcNetConnectOpts) & {
+    allowH2?: boolean;
+    maxCachedSessions?: number | null;
+    socketPath?: string | null;
+    timeout?: number | null;
+    port?: number;
+    keepAlive?: boolean | null;
+    keepAliveInitialDelay?: number | null;
+    typeOfService?: number | null;
+  };
+  export interface Options {
+    hostname: string;
+    host?: string;
+    protocol: string;
+    port: string;
+    servername?: string;
+    localAddress?: string | null;
+    socketPath?: string | null;
+    httpSocket?: Socket;
+  }
+  export type Callback = (...args: CallbackArgs) => void;
+  type CallbackArgs = [null, Socket | TLSSocket] | [Error, null];
+  export interface connector {
+    (options: buildConnector.Options, callback: buildConnector.Callback): void;
+  }
+}
+//#endregion
+//#region ../../node_modules/undici/types/client-stats.d.ts
+declare class ClientStats {
+  constructor(pool: Client);
+  /** If socket has open connection. */
+  connected: boolean;
+  /** Number of open socket connections in this client that do not have an active request. */
+  pending: number;
+  /** Number of currently active requests of this client. */
+  running: number;
+  /** Number of active, pending, or queued requests of this client. */
+  size: number;
+}
+//#endregion
+//#region ../../node_modules/undici/types/client.d.ts
+type ClientConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>;
+/**
+ * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
+ */
+declare class Client extends Dispatcher {
+  constructor(url: string | URL$1, options?: Client.Options);
+  /** Property to get and set the pipelining factor. */
+  pipelining: number;
+  /** `true` after `client.close()` has been called. */
+  closed: boolean;
+  /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
+  destroyed: boolean;
+  /** Aggregate stats for a Client. */
+  readonly stats: ClientStats; // Override dispatcher APIs.
+  override connect(options: ClientConnectOptions): Promise<Dispatcher.ConnectData>;
+  override connect(options: ClientConnectOptions, callback: (err: Error | null, data: Dispatcher.ConnectData) => void): void;
+}
+declare namespace Client {
+  export interface OptionsInterceptors {
+    Client: readonly Dispatcher.DispatchInterceptor[];
+  }
+  export interface Options {
+    /** TODO */
+    interceptors?: OptionsInterceptors;
+    /** The maximum length of request headers in bytes. Default: Node.js' `--max-http-header-size` or `16384` (16KiB). */
+    maxHeaderSize?: number;
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
+    headersTimeout?: number;
+    /** @deprecated unsupported socketTimeout, use headersTimeout & bodyTimeout instead */
+    socketTimeout?: never;
+    /** @deprecated unsupported requestTimeout, use headersTimeout & bodyTimeout instead */
+    requestTimeout?: never;
+    /** TODO */
+    connectTimeout?: number;
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). */
+    bodyTimeout?: number;
+    /** @deprecated unsupported idleTimeout, use keepAliveTimeout instead */
+    idleTimeout?: never;
+    /** @deprecated unsupported keepAlive, use pipelining=0 instead */
+    keepAlive?: never;
+    /** the timeout, in milliseconds, after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. Default: `4e3` milliseconds (4s). */
+    keepAliveTimeout?: number;
+    /** @deprecated unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead */
+    maxKeepAliveTimeout?: never;
+    /** the maximum allowed `idleTimeout`, in milliseconds, when overridden by *keep-alive* hints from the server. Default: `600e3` milliseconds (10min). */
+    keepAliveMaxTimeout?: number;
+    /** A number of milliseconds subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
+    keepAliveTimeoutThreshold?: number;
+    /** TODO */
+    socketPath?: string;
+    /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
+    pipelining?: number;
+    /** @deprecated use the connect option instead */
+    tls?: never;
+    /** If `true`, an error is thrown when the request content-length header doesn't match the length of the request body. Default: `true`. */
+    strictContentLength?: boolean;
+    /** TODO */
+    maxCachedSessions?: number;
+    /** TODO */
+    connect?: Partial<buildConnector.BuildOptions> | buildConnector.connector;
+    /** TODO */
+    maxRequestsPerClient?: number;
+    /** TODO */
+    localAddress?: string;
+    /** Max response body size in bytes, -1 is disabled */
+    maxResponseSize?: number;
+    /** Enables a family autodetection algorithm that loosely implements section 5 of RFC 8305. */
+    autoSelectFamily?: boolean;
+    /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
+    autoSelectFamilyAttemptTimeout?: number;
+    /**
+     * @description Enables support for H2 if the server has assigned bigger priority to it through ALPN negotiation.
+     * @default false
+     */
+    allowH2?: boolean;
+    /**
+     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+     * @default 100
+     */
+    maxConcurrentStreams?: number;
+    /**
+     * @description Sets the HTTP/2 stream-level flow-control window size (SETTINGS_INITIAL_WINDOW_SIZE).
+     * @default 262144
+     */
+    initialWindowSize?: number;
+    /**
+     * @description Sets the HTTP/2 connection-level flow-control window size (ClientHttp2Session.setLocalWindowSize).
+     * @default 524288
+     */
+    connectionWindowSize?: number;
+    /**
+     * @description Time interval between PING frames dispatch
+     * @default 60000
+     */
+    pingInterval?: number;
+  }
+  export interface SocketInfo {
+    localAddress?: string;
+    localPort?: number;
+    remoteAddress?: string;
+    remotePort?: number;
+    remoteFamily?: string;
+    timeout?: number;
+    bytesWritten?: number;
+    bytesRead?: number;
+  }
+}
+//#endregion
+//#region ../../node_modules/undici/types/errors.d.ts
+declare namespace Errors {
+  export class UndiciError extends Error {
+    name: string;
+    code: string;
+  }
+  /** Connect timeout error. */
+  export class ConnectTimeoutError extends UndiciError {
+    name: 'ConnectTimeoutError';
+    code: 'UND_ERR_CONNECT_TIMEOUT';
+  }
+  /** A header exceeds the `headersTimeout` option. */
+  export class HeadersTimeoutError extends UndiciError {
+    name: 'HeadersTimeoutError';
+    code: 'UND_ERR_HEADERS_TIMEOUT';
+  }
+  /** Headers overflow error. */
+  export class HeadersOverflowError extends UndiciError {
+    name: 'HeadersOverflowError';
+    code: 'UND_ERR_HEADERS_OVERFLOW';
+  }
+  /** A body exceeds the `bodyTimeout` option. */
+  export class BodyTimeoutError extends UndiciError {
+    name: 'BodyTimeoutError';
+    code: 'UND_ERR_BODY_TIMEOUT';
+  }
+  export class ResponseError extends UndiciError {
+    constructor(message: string, code: number, options: {
+      headers?: IncomingHttpHeaders | string[] | null;
+      body?: null | Record<string, any> | string;
+    });
+    name: 'ResponseError';
+    code: 'UND_ERR_RESPONSE';
+    statusCode: number;
+    body: null | Record<string, any> | string;
+    headers: IncomingHttpHeaders | string[] | null;
+  }
+  /** Passed an invalid argument. */
+  export class InvalidArgumentError extends UndiciError {
+    name: 'InvalidArgumentError';
+    code: 'UND_ERR_INVALID_ARG';
+  }
+  /** Returned an invalid value. */
+  export class InvalidReturnValueError extends UndiciError {
+    name: 'InvalidReturnValueError';
+    code: 'UND_ERR_INVALID_RETURN_VALUE';
+  }
+  /** The request has been aborted by the user. */
+  export class RequestAbortedError extends UndiciError {
+    name: 'AbortError';
+    code: 'UND_ERR_ABORTED';
+  }
+  /** Expected error with reason. */
+  export class InformationalError extends UndiciError {
+    name: 'InformationalError';
+    code: 'UND_ERR_INFO';
+  }
+  /** Request body length does not match content-length header. */
+  export class RequestContentLengthMismatchError extends UndiciError {
+    name: 'RequestContentLengthMismatchError';
+    code: 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH';
+  }
+  /** Response body length does not match content-length header. */
+  export class ResponseContentLengthMismatchError extends UndiciError {
+    name: 'ResponseContentLengthMismatchError';
+    code: 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH';
+  }
+  /** Trying to use a destroyed client. */
+  export class ClientDestroyedError extends UndiciError {
+    name: 'ClientDestroyedError';
+    code: 'UND_ERR_DESTROYED';
+  }
+  /** Trying to use a closed client. */
+  export class ClientClosedError extends UndiciError {
+    name: 'ClientClosedError';
+    code: 'UND_ERR_CLOSED';
+  }
+  /** There is an error with the socket. */
+  export class SocketError extends UndiciError {
+    name: 'SocketError';
+    code: 'UND_ERR_SOCKET';
+    socket: Client.SocketInfo | null;
+  }
+  /** Encountered unsupported functionality. */
+  export class NotSupportedError extends UndiciError {
+    name: 'NotSupportedError';
+    code: 'UND_ERR_NOT_SUPPORTED';
+  }
+  /** No upstream has been added to the BalancedPool. */
+  export class BalancedPoolMissingUpstreamError extends UndiciError {
+    name: 'MissingUpstreamError';
+    code: 'UND_ERR_BPL_MISSING_UPSTREAM';
+  }
+  export class HTTPParserError extends UndiciError {
+    name: 'HTTPParserError';
+    code: string;
+  }
+  /** The response exceed the length allowed. */
+  export class ResponseExceededMaxSizeError extends UndiciError {
+    name: 'ResponseExceededMaxSizeError';
+    code: 'UND_ERR_RES_EXCEEDED_MAX_SIZE';
+  }
+  export class RequestRetryError extends UndiciError {
+    constructor(message: string, statusCode: number, headers?: IncomingHttpHeaders | string[] | null, body?: null | Record<string, any> | string);
+    name: 'RequestRetryError';
+    code: 'UND_ERR_REQ_RETRY';
+    statusCode: number;
+    data: {
+      count: number;
+    };
+    headers: Record<string, string | string[]>;
+  }
+  export class SecureProxyConnectionError extends UndiciError {
+    constructor(cause?: Error, message?: string, options?: Record<any, any>);
+    name: 'SecureProxyConnectionError';
+    code: 'UND_ERR_PRX_TLS';
+  }
+  export class MaxOriginsReachedError extends UndiciError {
+    name: 'MaxOriginsReachedError';
+    code: 'UND_ERR_MAX_ORIGINS_REACHED';
+  }
+  /** SOCKS5 proxy related error. */
+  export class Socks5ProxyError extends UndiciError {
+    constructor(message?: string, code?: string);
+    name: 'Socks5ProxyError';
+    code: string;
+  }
+  /** WebSocket decompressed message exceeded maximum size. */
+  export class MessageSizeExceededError extends UndiciError {
+    name: 'MessageSizeExceededError';
+    code: 'UND_ERR_WS_MESSAGE_SIZE_EXCEEDED';
+  }
+}
+//#endregion
+//#region ../../node_modules/undici/types/dispatcher.d.ts
+type AbortSignal$1 = unknown;
+type UndiciHeaders = Record<string, string | string[]> | IncomingHttpHeaders | string[] | Iterable<[string, string | string[] | undefined]> | null;
+/** Dispatcher is the core API used to dispatch requests. */
+declare class Dispatcher extends EventEmitter {
+  /** Dispatches a request. This API is expected to evolve through semver-major versions and is less stable than the preceding higher level APIs. It is primarily intended for library developers who implement higher level APIs on top of this. */
+  dispatch(options: Dispatcher.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean;
+  /** Starts two-way communications with the requested resource. */
+  connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ConnectData<TOpaque>) => void): void;
+  connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>): Promise<Dispatcher.ConnectData<TOpaque>>;
+  /** Compose a chain of dispatchers */
+  compose(dispatchers: Dispatcher.DispatcherComposeInterceptor[]): Dispatcher.ComposedDispatcher;
+  compose(...dispatchers: Dispatcher.DispatcherComposeInterceptor[]): Dispatcher.ComposedDispatcher;
+  /** Performs an HTTP request. */
+  request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ResponseData<TOpaque>) => void): void;
+  request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>): Promise<Dispatcher.ResponseData<TOpaque>>;
+  /** For easy use with `stream.pipeline`. */
+  pipeline<TOpaque = null>(options: Dispatcher.PipelineOptions<TOpaque>, handler: Dispatcher.PipelineHandler<TOpaque>): Duplex$1;
+  /** A faster version of `Dispatcher.request`. */
+  stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>, callback: (err: Error | null, data: Dispatcher.StreamData<TOpaque>) => void): void;
+  stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>): Promise<Dispatcher.StreamData<TOpaque>>;
+  /** Upgrade to a different protocol. */
+  upgrade(options: Dispatcher.UpgradeOptions, callback: (err: Error | null, data: Dispatcher.UpgradeData) => void): void;
+  upgrade(options: Dispatcher.UpgradeOptions): Promise<Dispatcher.UpgradeData>;
+  /** Closes the client and gracefully waits for enqueued requests to complete before invoking the callback (or returning a promise if no callback is provided). */
+  close(callback: () => void): void;
+  close(): Promise<void>;
+  /** Destroy the client abruptly with the given err. All the pending and running requests will be asynchronously aborted and error. Waits until socket is closed before invoking the callback (or returning a promise if no callback is provided). Since this operation is asynchronously dispatched there might still be some progress on dispatched requests. */
+  destroy(err: Error | null, callback: () => void): void;
+  destroy(callback: () => void): void;
+  destroy(err: Error | null): Promise<void>;
+  destroy(): Promise<void>;
+  on(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  on(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  on(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  on(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  once(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  once(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  once(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  once(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  off(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  off(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  off(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  off(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  addListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  addListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  addListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  addListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  removeListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  removeListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  removeListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  removeListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  prependListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  prependListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  prependOnceListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  prependOnceListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependOnceListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependOnceListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  listeners(eventName: 'connect'): ((origin: URL$1, targets: readonly Dispatcher[]) => void)[];
+  listeners(eventName: 'disconnect'): ((origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  listeners(eventName: 'connectionError'): ((origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  listeners(eventName: 'drain'): ((origin: URL$1) => void)[];
+  rawListeners(eventName: 'connect'): ((origin: URL$1, targets: readonly Dispatcher[]) => void)[];
+  rawListeners(eventName: 'disconnect'): ((origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  rawListeners(eventName: 'connectionError'): ((origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  rawListeners(eventName: 'drain'): ((origin: URL$1) => void)[];
+  emit(eventName: 'connect', origin: URL$1, targets: readonly Dispatcher[]): boolean;
+  emit(eventName: 'disconnect', origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError): boolean;
+  emit(eventName: 'connectionError', origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError): boolean;
+  emit(eventName: 'drain', origin: URL$1): boolean;
+}
+declare namespace Dispatcher {
+  export interface ComposedDispatcher extends Dispatcher {}
+  export type Dispatch = Dispatcher['dispatch'];
+  export type DispatcherComposeInterceptor = (dispatch: Dispatch) => Dispatch;
+  export interface DispatchOptions {
+    origin?: string | URL$1;
+    path: string;
+    method: HttpMethod;
+    /** Default: `null` */
+    body?: string | Buffer | Uint8Array | Readable$1 | null | FormData$1;
+    /** Default: `null` */
+    headers?: UndiciHeaders;
+    /** Query string params to be embedded in the request URL. Default: `null` */
+    query?: Record<string, any>;
+    /** Whether the requests can be safely retried or not. If `false` the request won't be sent until all preceding requests in the pipeline have completed. Default: `true` if `method` is `HEAD` or `GET`. */
+    idempotent?: boolean;
+    /** Whether the response is expected to take a long time and would end up blocking the pipeline. When this is set to `true` further pipelining will be avoided on the same connection until headers have been received. Defaults to `method !== 'HEAD'`. */
+    blocking?: boolean;
+    /** The IP Type of Service (ToS) value for the request socket. Must be an integer between 0 and 255. Default: `0` */
+    typeOfService?: number | null;
+    /** Upgrade the request. Should be used to specify the kind of upgrade i.e. `'Websocket'`. Default: `method === 'CONNECT' || null`. */
+    upgrade?: boolean | string | null;
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers. Defaults to 300 seconds. */
+    headersTimeout?: number | null;
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use 0 to disable it entirely. Defaults to 300 seconds. */
+    bodyTimeout?: number | null;
+    /** Whether the request should stablish a keep-alive or not. Default `false` */
+    reset?: boolean;
+    /** Whether Undici should throw an error upon receiving a 4xx or 5xx response from the server. Defaults to false */
+    throwOnError?: boolean;
+    /** For H2, it appends the expect: 100-continue header, and halts the request body until a 100-continue is received from the remote server */
+    expectContinue?: boolean;
+  }
+  export interface ConnectOptions<TOpaque = null> {
+    origin: string | URL$1;
+    path: string;
+    /** Default: `null` */
+    headers?: UndiciHeaders;
+    /** Default: `null` */
+    signal?: AbortSignal$1 | EventEmitter | null;
+    /** This argument parameter is passed through to `ConnectData` */
+    opaque?: TOpaque;
+    /** Default: false */
+    redirectionLimitReached?: boolean;
+    /** Default: `null` */
+    responseHeaders?: 'raw' | null;
+  }
+  export interface RequestOptions<TOpaque = null> extends DispatchOptions {
+    /** Default: `null` */
+    opaque?: TOpaque;
+    /** Default: `null` */
+    signal?: AbortSignal$1 | EventEmitter | null;
+    /** Default: false */
+    redirectionLimitReached?: boolean;
+    /** Default: `null` */
+    onInfo?: (info: {
+      statusCode: number;
+      headers: Record<string, string | string[]>;
+    }) => void;
+    /** Default: `null` */
+    responseHeaders?: 'raw' | null;
+    /** Default: `64 KiB` */
+    highWaterMark?: number;
+  }
+  export interface PipelineOptions<TOpaque = null> extends RequestOptions<TOpaque> {
+    /** `true` if the `handler` will return an object stream. Default: `false` */
+    objectMode?: boolean;
+  }
+  export interface UpgradeOptions {
+    path: string;
+    /** Default: `'GET'` */
+    method?: string;
+    /** Default: `null` */
+    headers?: UndiciHeaders;
+    /** A string of comma separated protocols, in descending preference order. Default: `'Websocket'` */
+    protocol?: string;
+    /** Default: `null` */
+    signal?: AbortSignal$1 | EventEmitter | null;
+    /** Default: false */
+    redirectionLimitReached?: boolean;
+    /** Default: `null` */
+    responseHeaders?: 'raw' | null;
+  }
+  export interface ConnectData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    socket: Duplex$1;
+    opaque: TOpaque;
+  }
+  export interface ResponseData<TOpaque = null> {
+    statusCode: number;
+    statusText: string;
+    headers: IncomingHttpHeaders;
+    body: BodyReadable & BodyMixin;
+    trailers: Record<string, string>;
+    opaque: TOpaque;
+    context: object;
+  }
+  export interface PipelineHandlerData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    opaque: TOpaque;
+    body: BodyReadable;
+    context: object;
+  }
+  export interface StreamData<TOpaque = null> {
+    opaque: TOpaque;
+    trailers: Record<string, string>;
+  }
+  export interface UpgradeData<TOpaque = null> {
+    headers: IncomingHttpHeaders;
+    socket: Duplex$1;
+    opaque: TOpaque;
+  }
+  export interface StreamFactoryData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    opaque: TOpaque;
+    context: object;
+  }
+  export type StreamFactory<TOpaque = null> = (data: StreamFactoryData<TOpaque>) => Writable$1;
+  export interface DispatchController {
+    get aborted(): boolean;
+    get paused(): boolean;
+    get reason(): Error | null;
+    abort(reason: Error): void;
+    pause(): void;
+    resume(): void;
+  }
+  export interface DispatchHandler {
+    onRequestStart?(controller: DispatchController, context: any): void;
+    onRequestUpgrade?(controller: DispatchController, statusCode: number, headers: IncomingHttpHeaders, socket: Duplex$1): void;
+    onResponseStart?(controller: DispatchController, statusCode: number, headers: IncomingHttpHeaders, statusMessage?: string): void;
+    onResponseData?(controller: DispatchController, chunk: Buffer): void;
+    onResponseEnd?(controller: DispatchController, trailers: IncomingHttpHeaders): void;
+    onResponseError?(controller: DispatchController, error: Error): void;
+    /** Invoked before request is dispatched on socket. May be invoked multiple times when a request is retried when the request at the head of the pipeline fails. */
+    /** @deprecated */
+    onConnect?(abort: (err?: Error) => void): void;
+    /** Invoked when an error has occurred. */
+    /** @deprecated */
+    onError?(err: Error): void;
+    /** Invoked when request is upgraded either due to a `Upgrade` header or `CONNECT` method. */
+    /** @deprecated */
+    onUpgrade?(statusCode: number, headers: Buffer[] | string[] | null, socket: Duplex$1): void;
+    /** Invoked when response is received, before headers have been read. **/
+    /** @deprecated */
+    onResponseStarted?(): void;
+    /** Invoked when statusCode and headers have been received. May be invoked multiple times due to 1xx informational headers. */
+    /** @deprecated */
+    onHeaders?(statusCode: number, headers: Buffer[], resume: () => void, statusText: string): boolean;
+    /** Invoked when response payload data is received. */
+    /** @deprecated */
+    onData?(chunk: Buffer): boolean;
+    /** Invoked when response payload and trailers have been received and the request has completed. */
+    /** @deprecated */
+    onComplete?(trailers: string[] | null): void;
+    /** Invoked when a body chunk is sent to the server. May be invoked multiple times for chunked requests */
+    /** @deprecated */
+    onBodySent?(chunkSize: number, totalBytesSent: number): void;
+  }
+  export type PipelineHandler<TOpaque = null> = (data: PipelineHandlerData<TOpaque>) => Readable$1;
+  export type HttpMethod = Autocomplete<'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH'>;
+  /**
+   * @link https://fetch.spec.whatwg.org/#body-mixin
+   */
+  interface BodyMixin {
+    readonly body?: never;
+    readonly bodyUsed: boolean;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob>;
+    bytes(): Promise<Uint8Array>;
+    formData(): Promise<never>;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+  }
+  export interface DispatchInterceptor {
+    (dispatch: Dispatch): Dispatch;
+  }
+}
+//#endregion
+//#region ../../node_modules/undici/types/mock-interceptor.d.ts
+/** The scope associated with a mock dispatch. */
+declare class MockScope<TData extends object = object> {
+  constructor(mockDispatch: MockInterceptor.MockDispatch<TData>);
+  /** Delay a reply by a set amount of time in ms. */
+  delay(waitInMs: number): MockScope<TData>;
+  /** Persist the defined mock data for the associated reply. It will return the defined mock data indefinitely. */
+  persist(): MockScope<TData>;
+  /** Define a reply for a set amount of matching requests. */
+  times(repeatTimes: number): MockScope<TData>;
+}
+/** The interceptor for a Mock. */
+declare class MockInterceptor {
+  constructor(options: MockInterceptor.Options, mockDispatches: MockInterceptor.MockDispatch[]);
+  /** Mock an undici request with the defined reply. */
+  reply<TData extends object = object>(replyOptionsCallback: MockInterceptor.MockReplyOptionsCallback<TData>): MockScope<TData>;
+  reply<TData extends object = object>(statusCode: number, data?: TData | Buffer | string | MockInterceptor.MockResponseDataHandler<TData>, responseOptions?: MockInterceptor.MockResponseOptions): MockScope<TData>;
+  /** Mock an undici request by throwing the defined reply error. */
+  replyWithError<TError extends Error = Error>(error: TError): MockScope;
+  /** Set default reply headers on the interceptor for subsequent mocked replies. */
+  defaultReplyHeaders(headers: IncomingHttpHeaders): MockInterceptor;
+  /** Set default reply trailers on the interceptor for subsequent mocked replies. */
+  defaultReplyTrailers(trailers: Record<string, string>): MockInterceptor;
+  /** Set automatically calculated content-length header on subsequent mocked replies. */
+  replyContentLength(): MockInterceptor;
+}
+declare namespace MockInterceptor {
+  /** MockInterceptor options. */
+  export interface Options {
+    /** Path to intercept on. */
+    path: string | RegExp | ((path: string) => boolean);
+    /** Method to intercept on. Defaults to GET. */
+    method?: string | RegExp | ((method: string) => boolean);
+    /** Body to intercept on. */
+    body?: string | RegExp | ((body: string) => boolean);
+    /** Headers to intercept on. */
+    headers?: Record<string, string | RegExp | ((body: string) => boolean)> | ((headers: Record<string, string>) => boolean);
+    /** Query params to intercept on */
+    query?: Record<string, any>;
+  }
+  export interface MockDispatch<TData extends object = object, TError extends Error = Error> extends Options {
+    times: number | null;
+    persist: boolean;
+    consumed: boolean;
+    data: MockDispatchData<TData, TError>;
+  }
+  export interface MockDispatchData<TData extends object = object, TError extends Error = Error> extends MockResponseOptions {
+    error: TError | null;
+    statusCode?: number;
+    data?: TData | string;
+  }
+  export interface MockResponseOptions {
+    headers?: IncomingHttpHeaders;
+    trailers?: Record<string, string>;
+  }
+  export interface MockResponseCallbackOptions {
+    path: string;
+    method: string;
+    headers?: Headers$1 | Record<string, string>;
+    origin?: string;
+    body?: BodyInit | Dispatcher.DispatchOptions['body'] | null;
+  }
+  export type MockResponseDataHandler<TData extends object = object> = (opts: MockResponseCallbackOptions) => TData | Buffer | string;
+  export type MockReplyOptionsCallback<TData extends object = object> = (opts: MockResponseCallbackOptions) => {
+    statusCode: number;
+    data?: TData | Buffer | string;
+    responseOptions?: MockResponseOptions;
+  };
+}
+//#endregion
+//#region ../base/dist/helpers/request.d.ts
+interface RequestConfig {
+  baseURL?: string;
+  data?: unknown;
+  dispatcher?: Dispatcher;
+  headers?: Record<string, string | null | undefined>;
+  method?: string;
+  params?: Record<string, unknown>;
+  paramsSerializer?: ((params: Record<string, unknown>) => string) | {
+    serialize: (params: Record<string, unknown>) => string;
+  };
+  timeout?: number;
+  url?: string;
+}
+interface RequestResponse<T = any> {
+  config: RequestConfig;
+  data: T;
+  headers: Record<string, string>;
+  status: number;
+  statusText: string;
+}
+//#endregion
+//#region ../base/dist/helpers/tags.d.ts
+declare const CI_PIPELINE_URL = "ci.pipeline.url";
+declare const CI_PROVIDER_NAME = "ci.provider.name";
+declare const CI_PIPELINE_ID = "ci.pipeline.id";
+declare const CI_PIPELINE_NAME = "ci.pipeline.name";
+declare const CI_PIPELINE_NUMBER = "ci.pipeline.number";
+declare const CI_WORKSPACE_PATH = "ci.workspace_path";
+declare const GIT_REPOSITORY_URL = "git.repository_url";
+declare const CI_JOB_URL = "ci.job.url";
+declare const CI_JOB_NAME = "ci.job.name";
+declare const CI_JOB_ID = "ci.job.id";
+declare const CI_STAGE_NAME = "ci.stage.name";
+declare const CI_NODE_NAME = "ci.node.name";
+declare const CI_NODE_LABELS = "ci.node.labels";
+declare const CI_ENV_VARS = "_dd.ci.env_vars";
+declare const GIT_BRANCH = "git.branch";
+declare const GIT_COMMIT_AUTHOR_DATE = "git.commit.author.date";
+declare const GIT_COMMIT_AUTHOR_EMAIL = "git.commit.author.email";
+declare const GIT_COMMIT_AUTHOR_NAME = "git.commit.author.name";
+declare const GIT_COMMIT_COMMITTER_DATE = "git.commit.committer.date";
+declare const GIT_COMMIT_COMMITTER_EMAIL = "git.commit.committer.email";
+declare const GIT_COMMIT_COMMITTER_NAME = "git.commit.committer.name";
+declare const GIT_COMMIT_MESSAGE = "git.commit.message";
+declare const GIT_SHA = "git.commit.sha";
+declare const GIT_TAG = "git.tag";
+declare const GIT_HEAD_SHA = "git.commit.head.sha";
+declare const GIT_PULL_REQUEST_BASE_BRANCH_SHA = "git.pull_request.base_branch_sha";
+declare const GIT_PULL_REQUEST_BASE_BRANCH_HEAD_SHA = "git.pull_request.base_branch_head_sha";
+declare const GIT_PULL_REQUEST_BASE_BRANCH = "git.pull_request.base_branch";
+declare const PR_NUMBER = "pr.number";
+declare const SBOM_TOOL_GENERATOR_NAME = "tool.generator.name";
+declare const SBOM_TOOL_GENERATOR_VERSION = "tool.generator.version";
+declare const SERVICE = "service";
+//#endregion
+//#region ../base/dist/helpers/interfaces.d.ts
+type SpanTag = typeof CI_JOB_NAME | typeof CI_JOB_URL | typeof CI_JOB_ID | typeof CI_PIPELINE_ID | typeof CI_PIPELINE_NAME | typeof CI_PIPELINE_NUMBER | typeof CI_PIPELINE_URL | typeof CI_PROVIDER_NAME | typeof CI_STAGE_NAME | typeof CI_WORKSPACE_PATH | typeof GIT_BRANCH | typeof GIT_REPOSITORY_URL | typeof GIT_SHA | typeof GIT_TAG | typeof GIT_COMMIT_AUTHOR_EMAIL | typeof GIT_COMMIT_AUTHOR_NAME | typeof GIT_COMMIT_AUTHOR_DATE | typeof GIT_COMMIT_MESSAGE | typeof GIT_COMMIT_COMMITTER_DATE | typeof GIT_COMMIT_COMMITTER_EMAIL | typeof GIT_COMMIT_COMMITTER_NAME | typeof CI_ENV_VARS | typeof CI_NODE_NAME | typeof CI_NODE_LABELS | typeof SERVICE | typeof GIT_HEAD_SHA | typeof GIT_PULL_REQUEST_BASE_BRANCH | typeof GIT_PULL_REQUEST_BASE_BRANCH_SHA | typeof GIT_PULL_REQUEST_BASE_BRANCH_HEAD_SHA | typeof SBOM_TOOL_GENERATOR_NAME | typeof SBOM_TOOL_GENERATOR_VERSION | typeof PR_NUMBER;
+type SpanTags = Partial<Record<SpanTag, string>>;
+type RequestBuilder = (args: RequestConfig) => Promise<RequestResponse>;
+//#endregion
+//#region ../../node_modules/form-data/index.d.ts
+// Extracted because @types/node doesn't export interfaces.
+interface ReadableOptions {
+  highWaterMark?: number;
+  encoding?: string;
+  objectMode?: boolean;
+  read?(this: stream.Readable, size: number): void;
+  destroy?(this: stream.Readable, error: Error | null, callback: (error: Error | null) => void): void;
+  autoDestroy?: boolean;
+}
+interface Options$1 extends ReadableOptions {
+  writable?: boolean;
+  readable?: boolean;
+  dataSize?: number;
+  maxDataSize?: number;
+  pauseStreams?: boolean;
+}
+declare class FormData extends stream.Readable {
+  constructor(options?: Options$1);
+  append(key: string, value: any, options?: FormData.AppendOptions | string): void;
+  getHeaders(userHeaders?: FormData.Headers): FormData.Headers;
+  submit(params: string | FormData.SubmitOptions, callback?: (error: Error | null, response: http.IncomingMessage) => void): http.ClientRequest;
+  getBuffer(): Buffer;
+  setBoundary(boundary: string): void;
+  getBoundary(): string;
+  getLength(callback: (err: Error | null, length: number) => void): void;
+  getLengthSync(): number;
+  hasKnownLength(): boolean;
+}
+declare namespace FormData {
+  interface Headers {
+    [key: string]: any;
+  }
+  interface AppendOptions {
+    header?: string | Headers;
+    knownLength?: number;
+    filename?: string;
+    filepath?: string;
+    contentType?: string;
+  }
+  interface SubmitOptions extends http.RequestOptions {
+    protocol?: 'https:' | 'http:';
+  }
+}
+//#endregion
+//#region ../base/dist/helpers/upload.d.ts
+/** Multipart payload destined to be sent to Datadog's API
+ */
+interface MultipartPayload {
+  content: Map<string, MultipartValue>;
+}
+type MultipartValue = MultipartStringValue | MultipartFileValue;
+interface MultipartStringValue {
+  type: 'string';
+  value: string;
+  options: FormData.AppendOptions;
+}
+interface MultipartFileValue {
+  type: 'file';
+  path: string;
+  options: FormData.AppendOptions;
+}
+interface UploadOptions {
+  /** ApiKeyValidator (optional) throws an InvalidConfigurationException when upload fails because
+   * of an invalid API key. Callers should most likely catch this exception and display it as a
+   * nice error message.
+   */
+  apiKeyValidator?: ApiKeyValidator;
+  /** Retries is the amount of upload retries before giving up. Some requests are never retried
+   * (400, 413).
+   */
+  retries: number;
+  /** Whether to gzip the request */
+  useGzip?: boolean;
+  /** Callback when upload fails (retries are not considered as failure)
+   */
+  onError(error: Error): void;
+  /** Callback to execute before retries
+   */
+  onRetry(error: Error, attempts: number): void;
+  /** Callback to execute before upload.
+   */
+  onUpload(): void;
+}
+declare enum UploadStatus {
+  Success = 0,
+  Failure = 1,
+  Skipped = 2
+}
+//#endregion
+//#region ../base/dist/commands/git-metadata/interfaces.d.ts
+declare class CommitInfo {
+  hash: string;
+  remote: string;
+  trackedFiles: string[];
+  constructor(hash: string, remote: string, trackedFiles: string[]);
+  asMultipartPayload(cliVersion: string): MultipartPayload;
+  private getMetadataPayload;
+  private repositoryPayload;
+}
+declare namespace library_d_exports {
+  export { getGitCommitInfo, isGitRepo, uploadGitCommitHash, uploadRepository };
+}
+declare const isGitRepo: () => Promise<boolean>;
+declare const getGitCommitInfo: (filterAndFormatGitRepoUrl?: boolean) => Promise<[string, string]>;
+declare const uploadGitCommitHash: (apiKey: string, datadogSite: string, repositoryURL?: string) => Promise<[string, string]>;
+declare const uploadRepository: (requestBuilder: RequestBuilder, libraryVersion: string) => (commitInfo: CommitInfo, opts: UploadOptions) => Promise<UploadStatus>;
+//#endregion
+//#region ../../node_modules/proxy-agent/node_modules/lru-cache/index.d.ts
+// Project: https://github.com/isaacs/node-lru-cache
+// Based initially on @types/lru-cache
+// https://github.com/DefinitelyTyped/DefinitelyTyped
+// used under the terms of the MIT License, shown below.
+//
+// DefinitelyTyped license:
+// ------
+// MIT License
+//
+// Copyright (c) Microsoft Corporation.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
+// ------
+//
+// Changes by Isaac Z. Schlueter released under the terms found in the
+// LICENSE file within this project.
+/**
+ * Integer greater than 0, representing some number of milliseconds, or the
+ * time at which a TTL started counting from.
+ */
+declare type LRUMilliseconds = number;
+/**
+ * An integer greater than 0, reflecting the calculated size of items
+ */
+declare type LRUSize = number;
+/**
+ * An integer greater than 0, reflecting a number of items
+ */
+declare type LRUCount = number;
+declare class LRUCache<K, V> implements Iterable<[K, V]> {
+  constructor(options: LRUCache.Options<K, V>);
+  /**
+   * Number of items in the cache.
+   * Alias for {@link size}
+   *
+   * @deprecated since 7.0 use {@link size} instead
+   */
+  public readonly length: LRUCount;
+  public readonly max: LRUCount;
+  public readonly maxSize: LRUSize;
+  public readonly maxEntrySize: LRUSize;
+  public readonly sizeCalculation: LRUCache.SizeCalculator<K, V> | undefined;
+  public readonly dispose: LRUCache.Disposer<K, V>;
+  /**
+   * @since 7.4.0
+   */
+  public readonly disposeAfter: LRUCache.Disposer<K, V> | null;
+  public readonly noDisposeOnSet: boolean;
+  public readonly ttl: LRUMilliseconds;
+  public readonly ttlResolution: LRUMilliseconds;
+  public readonly ttlAutopurge: boolean;
+  public readonly allowStale: boolean;
+  public readonly updateAgeOnGet: boolean;
+  /**
+   * @since 7.11.0
+   */
+  public readonly noDeleteOnStaleGet: boolean;
+  /**
+   * @since 7.6.0
+   */
+  public readonly fetchMethod: LRUCache.Fetcher<K, V> | null;
+  /**
+   * The total number of items held in the cache at the current moment.
+   */
+  public readonly size: LRUCount;
+  /**
+   * The total size of items in cache when using size tracking.
+   */
+  public readonly calculatedSize: LRUSize;
+  /**
+   * Add a value to the cache.
+   */
+  public set(key: K, value: V, options?: LRUCache.SetOptions<K, V>): this;
+  /**
+   * Return a value from the cache. Will update the recency of the cache entry
+   * found.
+   *
+   * If the key is not found, {@link get} will return `undefined`. This can be
+   * confusing when setting values specifically to `undefined`, as in
+   * `cache.set(key, undefined)`. Use {@link has} to determine whether a key is
+   * present in the cache at all.
+   */
+  public get(key: K, options?: LRUCache.GetOptions<V>): V | undefined;
+  /**
+   * Like {@link get} but doesn't update recency or delete stale items.
+   * Returns `undefined` if the item is stale, unless {@link allowStale} is set
+   * either on the cache or in the options object.
+   */
+  public peek(key: K, options?: LRUCache.PeekOptions): V | undefined;
+  /**
+   * Check if a key is in the cache, without updating the recency of use.
+   * Will return false if the item is stale, even though it is technically
+   * in the cache.
+   *
+   * Will not update item age unless {@link updateAgeOnHas} is set in the
+   * options or constructor.
+   */
+  public has(key: K, options?: LRUCache.HasOptions<V>): boolean;
+  /**
+   * Deletes a key out of the cache.
+   * Returns true if the key was deleted, false otherwise.
+   */
+  public delete(key: K): boolean;
+  /**
+   * Clear the cache entirely, throwing away all values.
+   */
+  public clear(): void;
+  /**
+   * Delete any stale entries. Returns true if anything was removed, false
+   * otherwise.
+   */
+  public purgeStale(): boolean;
+  /**
+   * Find a value for which the supplied fn method returns a truthy value,
+   * similar to Array.find().  fn is called as fn(value, key, cache).
+   */
+  public find(callbackFn: (value: V, key: K, cache: this) => boolean | undefined | void, options?: LRUCache.GetOptions<V>): V | undefined;
+  /**
+   * Call the supplied function on each item in the cache, in order from
+   * most recently used to least recently used.  fn is called as
+   * fn(value, key, cache).  Does not update age or recenty of use.
+   */
+  public forEach<T = this>(callbackFn: (this: T, value: V, key: K, cache: this) => void, thisArg?: T): void;
+  /**
+   * The same as {@link forEach} but items are iterated over in reverse
+   * order.  (ie, less recently used items are iterated over first.)
+   */
+  public rforEach<T = this>(callbackFn: (this: T, value: V, key: K, cache: this) => void, thisArg?: T): void;
+  /**
+   * Return a generator yielding the keys in the cache,
+   * in order from most recently used to least recently used.
+   */
+  public keys(): Generator<K, void, void>;
+  /**
+   * Inverse order version of {@link keys}
+   *
+   * Return a generator yielding the keys in the cache,
+   * in order from least recently used to most recently used.
+   */
+  public rkeys(): Generator<K, void, void>;
+  /**
+   * Return a generator yielding the values in the cache,
+   * in order from most recently used to least recently used.
+   */
+  public values(): Generator<V, void, void>;
+  /**
+   * Inverse order version of {@link values}
+   *
+   * Return a generator yielding the values in the cache,
+   * in order from least recently used to most recently used.
+   */
+  public rvalues(): Generator<V, void, void>;
+  /**
+   * Return a generator yielding `[key, value]` pairs,
+   * in order from most recently used to least recently used.
+   */
+  public entries(): Generator<[K, V], void, void>;
+  /**
+   * Inverse order version of {@link entries}
+   *
+   * Return a generator yielding `[key, value]` pairs,
+   * in order from least recently used to most recently used.
+   */
+  public rentries(): Generator<[K, V], void, void>;
+  /**
+   * Iterating over the cache itself yields the same results as
+   * {@link entries}
+   */
+  public [Symbol.iterator](): Generator<[K, V], void, void>;
+  /**
+   * Return an array of [key, entry] objects which can be passed to
+   * cache.load()
+   */
+  public dump(): Array<[K, LRUCache.Entry<V>]>;
+  /**
+   * Reset the cache and load in the items in entries in the order listed.
+   * Note that the shape of the resulting cache may be different if the
+   * same options are not used in both caches.
+   */
+  public load(cacheEntries: ReadonlyArray<[K, LRUCache.Entry<V>]>): void;
+  /**
+   * Evict the least recently used item, returning its value or `undefined`
+   * if cache is empty.
+   */
+  public pop(): V | undefined;
+  /**
+   * Deletes a key out of the cache.
+   *
+   * @deprecated since 7.0 use delete() instead
+   */
+  public del(key: K): boolean;
+  /**
+   * Clear the cache entirely, throwing away all values.
+   *
+   * @deprecated since 7.0 use clear() instead
+   */
+  public reset(): void;
+  /**
+   * Manually iterates over the entire cache proactively pruning old entries.
+   *
+   * @deprecated since 7.0 use purgeStale() instead
+   */
+  public prune(): boolean;
+  /**
+   * Make an asynchronous cached fetch using the {@link fetchMethod} function.
+   *
+   * If multiple fetches for the same key are issued, then they will all be
+   * coalesced into a single call to fetchMethod.
+   *
+   * Note that this means that handling options such as
+   * {@link allowStaleOnFetchAbort}, {@link signal}, and
+   * {@link allowStaleOnFetchRejection} will be determined by the FIRST fetch()
+   * call for a given key.
+   *
+   * This is a known (fixable) shortcoming which will be addresed on when
+   * someone complains about it, as the fix would involve added complexity and
+   * may not be worth the costs for this edge case.
+   *
+   * since: 7.6.0
+   */
+  public fetch(key: K, options?: LRUCache.FetchOptions<K, V>): Promise<V>;
+  /**
+   * since: 7.6.0
+   */
+  public getRemainingTTL(key: K): LRUMilliseconds;
+}
+declare namespace LRUCache {
+  type DisposeReason = 'evict' | 'set' | 'delete';
+  type SizeCalculator<K, V> = (value: V, key: K) => LRUSize;
+  type Disposer<K, V> = (value: V, key: K, reason: DisposeReason) => void;
+  type Fetcher<K, V> = (key: K, staleValue: V | undefined, options: FetcherOptions<K, V>) => Promise<V | void | undefined> | V | void | undefined;
+  interface DeprecatedOptions<K, V> {
+    /**
+     * alias for ttl
+     *
+     * @deprecated since 7.0 use options.ttl instead
+     */
+    maxAge?: LRUMilliseconds;
+    /**
+     * alias for {@link sizeCalculation}
+     *
+     * @deprecated since 7.0 use {@link sizeCalculation} instead
+     */
+    length?: SizeCalculator<K, V>;
+    /**
+     * alias for allowStale
+     *
+     * @deprecated since 7.0 use options.allowStale instead
+     */
+    stale?: boolean;
+  }
+  interface LimitedByCount {
+    /**
+     * The number of most recently used items to keep.
+     * Note that we may store fewer items than this if maxSize is hit.
+     */
+    max: LRUCount;
+  }
+  type MaybeMaxEntrySizeLimit<K, V> = {
+    /**
+     * The maximum allowed size for any single item in the cache.
+     *
+     * If a larger item is passed to {@link set} or returned by a
+     * {@link fetchMethod}, then it will not be stored in the cache.
+     */
+    maxEntrySize: LRUSize;
+    sizeCalculation?: SizeCalculator<K, V>;
+  } | {};
+  interface LimitedBySize<K, V> {
+    /**
+     * If you wish to track item size, you must provide a maxSize
+     * note that we still will only keep up to max *actual items*,
+     * if max is set, so size tracking may cause fewer than max items
+     * to be stored.  At the extreme, a single item of maxSize size
+     * will cause everything else in the cache to be dropped when it
+     * is added.  Use with caution!
+     *
+     * Note also that size tracking can negatively impact performance,
+     * though for most cases, only minimally.
+     */
+    maxSize: LRUSize;
+    /**
+     * Function to calculate size of items.  Useful if storing strings or
+     * buffers or other items where memory size depends on the object itself.
+     *
+     * Items larger than {@link maxEntrySize} will not be stored in the cache.
+     *
+     * Note that when {@link maxSize} or {@link maxEntrySize} are set, every
+     * item added MUST have a size specified, either via a `sizeCalculation` in
+     * the constructor, or `sizeCalculation` or {@link size} options to
+     * {@link set}.
+     */
+    sizeCalculation?: SizeCalculator<K, V>;
+  }
+  interface LimitedByTTL {
+    /**
+     * Max time in milliseconds for items to live in cache before they are
+     * considered stale.  Note that stale items are NOT preemptively removed
+     * by default, and MAY live in the cache, contributing to its LRU max,
+     * long after they have expired.
+     *
+     * Also, as this cache is optimized for LRU/MRU operations, some of
+     * the staleness/TTL checks will reduce performance, as they will incur
+     * overhead by deleting items.
+     *
+     * Must be an integer number of ms, defaults to 0, which means "no TTL"
+     */
+    ttl: LRUMilliseconds;
+    /**
+     * Boolean flag to tell the cache to not update the TTL when
+     * setting a new value for an existing key (ie, when updating a value
+     * rather than inserting a new value).  Note that the TTL value is
+     * _always_ set (if provided) when adding a new entry into the cache.
+     *
+     * @default false
+     * @since 7.4.0
+     */
+    noUpdateTTL?: boolean;
+    /**
+     * Minimum amount of time in ms in which to check for staleness.
+     * Defaults to 1, which means that the current time is checked
+     * at most once per millisecond.
+     *
+     * Set to 0 to check the current time every time staleness is tested.
+     * (This reduces performance, and is theoretically unnecessary.)
+     *
+     * Setting this to a higher value will improve performance somewhat
+     * while using ttl tracking, albeit at the expense of keeping stale
+     * items around a bit longer than their TTLs would indicate.
+     *
+     * @default 1
+     * @since 7.1.0
+     */
+    ttlResolution?: LRUMilliseconds;
+    /**
+     * Preemptively remove stale items from the cache.
+     * Note that this may significantly degrade performance,
+     * especially if the cache is storing a large number of items.
+     * It is almost always best to just leave the stale items in
+     * the cache, and let them fall out as new items are added.
+     *
+     * Note that this means that {@link allowStale} is a bit pointless,
+     * as stale items will be deleted almost as soon as they expire.
+     *
+     * Use with caution!
+     *
+     * @default false
+     * @since 7.1.0
+     */
+    ttlAutopurge?: boolean;
+    /**
+     * Return stale items from {@link get} before disposing of them.
+     * Return stale values from {@link fetch} while performing a call
+     * to the {@link fetchMethod} in the background.
+     *
+     * @default false
+     */
+    allowStale?: boolean;
+    /**
+     * Update the age of items on {@link get}, renewing their TTL
+     *
+     * @default false
+     */
+    updateAgeOnGet?: boolean;
+    /**
+     * Do not delete stale items when they are retrieved with {@link get}.
+     * Note that the {@link get} return value will still be `undefined` unless
+     * allowStale is true.
+     *
+     * @default false
+     * @since 7.11.0
+     */
+    noDeleteOnStaleGet?: boolean;
+    /**
+     * Update the age of items on {@link has}, renewing their TTL
+     *
+     * @default false
+     */
+    updateAgeOnHas?: boolean;
+  }
+  type SafetyBounds<K, V> = LimitedByCount | LimitedBySize<K, V> | LimitedByTTL; // options shared by all three of the limiting scenarios
+  interface SharedOptions<K, V> {
+    /**
+     * Function that is called on items when they are dropped from the cache.
+     * This can be handy if you want to close file descriptors or do other
+     * cleanup tasks when items are no longer accessible. Called with `key,
+     * value`.  It's called before actually removing the item from the
+     * internal cache, so it is *NOT* safe to re-add them.
+     * Use {@link disposeAfter} if you wish to dispose items after they have
+     * been full removed, when it is safe to add them back to the cache.
+     */
+    dispose?: Disposer<K, V>;
+    /**
+     * The same as dispose, but called *after* the entry is completely
+     * removed and the cache is once again in a clean state.  It is safe to
+     * add an item right back into the cache at this point.
+     * However, note that it is *very* easy to inadvertently create infinite
+     * recursion this way.
+     *
+     * @since 7.3.0
+     */
+    disposeAfter?: Disposer<K, V>;
+    /**
+     * Set to true to suppress calling the dispose() function if the entry
+     * key is still accessible within the cache.
+     * This may be overridden by passing an options object to {@link set}.
+     *
+     * @default false
+     */
+    noDisposeOnSet?: boolean;
+    /**
+     * Function that is used to make background asynchronous fetches.  Called
+     * with `fetchMethod(key, staleValue, { signal, options, context })`.
+     *
+     * If `fetchMethod` is not provided, then {@link fetch} is
+     * equivalent to `Promise.resolve(cache.get(key))`.
+     *
+     * The `fetchMethod` should ONLY return `undefined` in cases where the
+     * abort controller has sent an abort signal.
+     *
+     * @since 7.6.0
+     */
+    fetchMethod?: LRUCache.Fetcher<K, V>;
+    /**
+     * Set to true to suppress the deletion of stale data when a
+     * {@link fetchMethod} throws an error or returns a rejected promise
+     *
+     * This may be overridden in the {@link fetchMethod}.
+     *
+     * @default false
+     * @since 7.10.0
+     */
+    noDeleteOnFetchRejection?: boolean;
+    /**
+     * Set to true to allow returning stale data when a {@link fetchMethod}
+     * throws an error or returns a rejected promise. Note that this
+     * differs from using {@link allowStale} in that stale data will
+     * ONLY be returned in the case that the fetch fails, not any other
+     * times.
+     *
+     * This may be overridden in the {@link fetchMethod}.
+     *
+     * @default false
+     * @since 7.16.0
+     */
+    allowStaleOnFetchRejection?: boolean;
+    /**
+     *
+     * Set to true to ignore the `abort` event emitted by the `AbortSignal`
+     * object passed to {@link fetchMethod}, and still cache the
+     * resulting resolution value, as long as it is not `undefined`.
+     *
+     * When used on its own, this means aborted {@link fetch} calls are not
+     * immediately resolved or rejected when they are aborted, and instead take
+     * the full time to await.
+     *
+     * When used with {@link allowStaleOnFetchAbort}, aborted {@link fetch}
+     * calls will resolve immediately to their stale cached value or
+     * `undefined`, and will continue to process and eventually update the
+     * cache when they resolve, as long as the resulting value is not
+     * `undefined`, thus supporting a "return stale on timeout while
+     * refreshing" mechanism by passing `AbortSignal.timeout(n)` as the signal.
+     *
+     * **Note**: regardless of this setting, an `abort` event _is still emitted
+     * on the `AbortSignal` object_, so may result in invalid results when
+     * passed to other underlying APIs that use AbortSignals.
+     *
+     * This may be overridden in the {@link fetchMethod} or the call to
+     * {@link fetch}.
+     *
+     * @default false
+     * @since 7.17.0
+     */
+    ignoreFetchAbort?: boolean;
+    /**
+     * Set to true to return a stale value from the cache when the
+     * `AbortSignal` passed to the {@link fetchMethod} dispatches an `'abort'`
+     * event, whether user-triggered, or due to internal cache behavior.
+     *
+     * Unless {@link ignoreFetchAbort} is also set, the underlying
+     * {@link fetchMethod} will still be considered canceled, and its return
+     * value will be ignored and not cached.
+     *
+     * This may be overridden in the {@link fetchMethod} or the call to
+     * {@link fetch}.
+     *
+     * @default false
+     * @since 7.17.0
+     */
+    allowStaleOnFetchAbort?: boolean;
+    /**
+     * Set to any value in the constructor or {@link fetch} options to
+     * pass arbitrary data to the {@link fetchMethod} in the {@link context}
+     * options field.
+     *
+     * @since 7.12.0
+     */
+    fetchContext?: any;
+  }
+  type Options<K, V> = SharedOptions<K, V> & DeprecatedOptions<K, V> & SafetyBounds<K, V> & MaybeMaxEntrySizeLimit<K, V>;
+  /**
+   * options which override the options set in the LRUCache constructor
+   * when making calling {@link set}.
+   */
+  interface SetOptions<K, V> {
+    /**
+     * A value for the size of the entry, prevents calls to
+     * {@link sizeCalculation}.
+     *
+     * Items larger than {@link maxEntrySize} will not be stored in the cache.
+     *
+     * Note that when {@link maxSize} or {@link maxEntrySize} are set, every
+     * item added MUST have a size specified, either via a `sizeCalculation` in
+     * the constructor, or {@link sizeCalculation} or `size` options to
+     * {@link set}.
+     */
+    size?: LRUSize;
+    /**
+     * Overrides the {@link sizeCalculation} method set in the constructor.
+     *
+     * Items larger than {@link maxEntrySize} will not be stored in the cache.
+     *
+     * Note that when {@link maxSize} or {@link maxEntrySize} are set, every
+     * item added MUST have a size specified, either via a `sizeCalculation` in
+     * the constructor, or `sizeCalculation` or {@link size} options to
+     * {@link set}.
+     */
+    sizeCalculation?: SizeCalculator<K, V>;
+    ttl?: LRUMilliseconds;
+    start?: LRUMilliseconds;
+    noDisposeOnSet?: boolean;
+    noUpdateTTL?: boolean;
+    status?: Status<V>;
+  }
+  /**
+   * options which override the options set in the LRUCAche constructor
+   * when calling {@link has}.
+   */
+  interface HasOptions<V> {
+    updateAgeOnHas?: boolean;
+    status: Status<V>;
+  }
+  /**
+   * options which override the options set in the LRUCache constructor
+   * when calling {@link get}.
+   */
+  interface GetOptions<V> {
+    allowStale?: boolean;
+    updateAgeOnGet?: boolean;
+    noDeleteOnStaleGet?: boolean;
+    status?: Status<V>;
+  }
+  /**
+   * options which override the options set in the LRUCache constructor
+   * when calling {@link peek}.
+   */
+  interface PeekOptions {
+    allowStale?: boolean;
+  }
+  /**
+   * Options object passed to the {@link fetchMethod}
+   *
+   * May be mutated by the {@link fetchMethod} to affect the behavior of the
+   * resulting {@link set} operation on resolution, or in the case of
+   * {@link noDeleteOnFetchRejection}, {@link ignoreFetchAbort}, and
+   * {@link allowStaleOnFetchRejection}, the handling of failure.
+   */
+  interface FetcherFetchOptions<K, V> {
+    allowStale?: boolean;
+    updateAgeOnGet?: boolean;
+    noDeleteOnStaleGet?: boolean;
+    size?: LRUSize;
+    sizeCalculation?: SizeCalculator<K, V>;
+    ttl?: LRUMilliseconds;
+    noDisposeOnSet?: boolean;
+    noUpdateTTL?: boolean;
+    noDeleteOnFetchRejection?: boolean;
+    allowStaleOnFetchRejection?: boolean;
+    ignoreFetchAbort?: boolean;
+    allowStaleOnFetchAbort?: boolean;
+    status?: Status<V>;
+  }
+  /**
+   * Status object that may be passed to {@link fetch}, {@link get},
+   * {@link set}, and {@link has}.
+   */
+  interface Status<V> {
+    /**
+     * The status of a set() operation.
+     *
+     * - add: the item was not found in the cache, and was added
+     * - update: the item was in the cache, with the same value provided
+     * - replace: the item was in the cache, and replaced
+     * - miss: the item was not added to the cache for some reason
+     */
+    set?: 'add' | 'update' | 'replace' | 'miss';
+    /**
+     * the ttl stored for the item, or undefined if ttls are not used.
+     */
+    ttl?: LRUMilliseconds;
+    /**
+     * the start time for the item, or undefined if ttls are not used.
+     */
+    start?: LRUMilliseconds;
+    /**
+     * The timestamp used for TTL calculation
+     */
+    now?: LRUMilliseconds;
+    /**
+     * the remaining ttl for the item, or undefined if ttls are not used.
+     */
+    remainingTTL?: LRUMilliseconds;
+    /**
+     * The calculated size for the item, if sizes are used.
+     */
+    size?: LRUSize;
+    /**
+     * A flag indicating that the item was not stored, due to exceeding the
+     * {@link maxEntrySize}
+     */
+    maxEntrySizeExceeded?: true;
+    /**
+     * The old value, specified in the case of `set:'update'` or
+     * `set:'replace'`
+     */
+    oldValue?: V;
+    /**
+     * The results of a {@link has} operation
+     *
+     * - hit: the item was found in the cache
+     * - stale: the item was found in the cache, but is stale
+     * - miss: the item was not found in the cache
+     */
+    has?: 'hit' | 'stale' | 'miss';
+    /**
+     * The status of a {@link fetch} operation.
+     * Note that this can change as the underlying fetch() moves through
+     * various states.
+     *
+     * - inflight: there is another fetch() for this key which is in process
+     * - get: there is no fetchMethod, so {@link get} was called.
+     * - miss: the item is not in cache, and will be fetched.
+     * - hit: the item is in the cache, and was resolved immediately.
+     * - stale: the item is in the cache, but stale.
+     * - refresh: the item is in the cache, and not stale, but
+     *   {@link forceRefresh} was specified.
+     */
+    fetch?: 'get' | 'inflight' | 'miss' | 'hit' | 'stale' | 'refresh';
+    /**
+     * The {@link fetchMethod} was called
+     */
+    fetchDispatched?: true;
+    /**
+     * The cached value was updated after a successful call to fetchMethod
+     */
+    fetchUpdated?: true;
+    /**
+     * The reason for a fetch() rejection.  Either the error raised by the
+     * {@link fetchMethod}, or the reason for an AbortSignal.
+     */
+    fetchError?: Error;
+    /**
+     * The fetch received an abort signal
+     */
+    fetchAborted?: true;
+    /**
+     * The abort signal received was ignored, and the fetch was allowed to
+     * continue.
+     */
+    fetchAbortIgnored?: true;
+    /**
+     * The fetchMethod promise resolved successfully
+     */
+    fetchResolved?: true;
+    /**
+     * The fetchMethod promise was rejected
+     */
+    fetchRejected?: true;
+    /**
+     * The status of a {@link get} operation.
+     *
+     * - fetching: The item is currently being fetched.  If a previous value is
+     *   present and allowed, that will be returned.
+     * - stale: The item is in the cache, and is stale.
+     * - hit: the item is in the cache
+     * - miss: the item is not in the cache
+     */
+    get?: 'stale' | 'hit' | 'miss';
+    /**
+     * A fetch or get operation returned a stale value.
+     */
+    returnedStale?: true;
+  }
+  /**
+   * options which override the options set in the LRUCache constructor
+   * when calling {@link fetch}.
+   *
+   * This is the union of GetOptions and SetOptions, plus
+   * {@link noDeleteOnFetchRejection}, {@link allowStaleOnFetchRejection},
+   * {@link forceRefresh}, and {@link fetchContext}
+   */
+  interface FetchOptions<K, V> extends FetcherFetchOptions<K, V> {
+    forceRefresh?: boolean;
+    fetchContext?: any;
+    signal?: AbortSignal;
+    status?: Status<V>;
+  }
+  interface FetcherOptions<K, V> {
+    signal: AbortSignal;
+    options: FetcherFetchOptions<K, V>;
+    /**
+     * Object provided in the {@link fetchContext} option
+     */
+    context: any;
+  }
+  interface Entry<V> {
+    value: V;
+    ttl?: LRUMilliseconds;
+    size?: LRUSize;
+    start?: LRUMilliseconds;
+  }
+}
+//#endregion
+//#region ../../node_modules/agent-base/dist/index.d.ts
+interface HttpConnectOpts extends net.TcpNetConnectOpts {
+  secureEndpoint: false;
+  protocol?: string;
+}
+interface HttpsConnectOpts extends tls.ConnectionOptions {
+  secureEndpoint: true;
+  protocol?: string;
+  port: number;
+}
+type AgentConnectOpts = HttpConnectOpts | HttpsConnectOpts;
+declare const INTERNAL: unique symbol;
+declare abstract class Agent extends http.Agent {
+  private [INTERNAL];
+  options: Partial<net.TcpNetConnectOpts & tls.ConnectionOptions>;
+  keepAlive: boolean;
+  constructor(opts?: http.AgentOptions);
+  abstract connect(req: http.ClientRequest, options: AgentConnectOpts): Promise<Duplex | http.Agent> | Duplex | http.Agent;
+  /**
+   * Determine whether this is an `http` or `https` request.
+   */
+  isSecureEndpoint(options?: AgentConnectOpts): boolean;
+  private incrementSockets;
+  private decrementSockets;
+  getName(options: AgentConnectOpts): string;
+  createSocket(req: http.ClientRequest, options: AgentConnectOpts, cb: (err: Error | null, s?: Duplex) => void): void;
+  createConnection(): Duplex;
+  get defaultPort(): number;
+  set defaultPort(v: number);
+  get protocol(): string;
+  set protocol(v: string);
+}
+//#endregion
+//#region ../../node_modules/http-proxy-agent/dist/index.d.ts
+type Protocol$3<T> = T extends `${infer Protocol}:${infer _}` ? Protocol : never;
+type ConnectOptsMap$1 = {
+  http: Omit<net.TcpNetConnectOpts, 'host' | 'port'>;
+  https: Omit<tls.ConnectionOptions, 'host' | 'port'>;
+};
+type ConnectOpts$1<T> = { [P in keyof ConnectOptsMap$1]: Protocol$3<T> extends P ? ConnectOptsMap$1[P] : never }[keyof ConnectOptsMap$1];
+type HttpProxyAgentOptions<T> = ConnectOpts$1<T> & http.AgentOptions & {
+  headers?: OutgoingHttpHeaders | (() => OutgoingHttpHeaders);
+};
+//#endregion
+//#region ../../node_modules/https-proxy-agent/dist/index.d.ts
+type Protocol$2<T> = T extends `${infer Protocol}:${infer _}` ? Protocol : never;
+type ConnectOptsMap = {
+  http: Omit<net.TcpNetConnectOpts, 'host' | 'port'>;
+  https: Omit<tls.ConnectionOptions, 'host' | 'port'>;
+};
+type ConnectOpts<T> = { [P in keyof ConnectOptsMap]: Protocol$2<T> extends P ? ConnectOptsMap[P] : never }[keyof ConnectOptsMap];
+type HttpsProxyAgentOptions<T> = ConnectOpts<T> & http.AgentOptions & {
+  headers?: OutgoingHttpHeaders | (() => OutgoingHttpHeaders);
+};
+//#endregion
+//#region ../../node_modules/socks/typings/common/constants.d.ts
+type SocksProxyType = 4 | 5;
+/**
+ * Represents a SocksProxy
+ */
+interface SocksProxy {
+  ipaddress?: string;
+  host?: string;
+  port: number;
+  type: SocksProxyType;
+  userId?: string;
+  password?: string;
+  custom_auth_method?: number;
+  custom_auth_request_handler?: () => Promise<Buffer>;
+  custom_auth_response_size?: number;
+  custom_auth_response_handler?: (data: Buffer) => Promise<boolean>;
+}
+/**
+ * Represents a remote host
+ */
+//#endregion
+//#region ../../node_modules/socks-proxy-agent/dist/index.d.ts
+type SocksSocketOptions = Omit<net.TcpNetConnectOpts, 'port' | 'host'>;
+type SocksProxyAgentOptions = Omit<SocksProxy, 'ipaddress' | 'host' | 'port' | 'type' | 'userId' | 'password'> & {
+  socketOptions?: SocksSocketOptions;
+} & http.AgentOptions;
+//#endregion
+//#region ../../node_modules/get-uri/dist/data.d.ts
+declare class DataReadable extends Readable {
+  hash?: string;
+  constructor(hash: string, buf: Buffer);
+}
+interface DataOptions {
+  cache?: DataReadable;
+}
+//#endregion
+//#region ../../node_modules/get-uri/dist/file.d.ts
+type ReadStreamOptions = NonNullable<Exclude<Parameters<typeof createReadStream>[1], string>>;
+interface FileReadable extends Readable {
+  stat?: Stats;
+}
+interface FileOptions extends ReadStreamOptions {
+  cache?: FileReadable;
+}
+//#endregion
+//#region ../../node_modules/basic-ftp/dist/Client.d.ts
+interface AccessOptions {
+  /** Host the client should connect to. Optional, default is "localhost". */
+  readonly host?: string;
+  /** Port the client should connect to. Optional, default is 21. */
+  readonly port?: number;
+  /** Username to use for login. Optional, default is "anonymous". */
+  readonly user?: string;
+  /** Password to use for login. Optional, default is "guest". */
+  readonly password?: string;
+  /** Use FTPS over TLS. Optional, default is false. True is preferred explicit TLS, "implicit" supports legacy, non-standardized implicit TLS. */
+  readonly secure?: boolean | "implicit";
+  /** TLS options as in [tls.connect(options)](https://nodejs.org/api/tls.html#tls_tls_connect_options_callback), optional. */
+  readonly secureOptions?: ConnectionOptions$1;
+}
+//#endregion
+//#region ../../node_modules/get-uri/dist/ftp.d.ts
+interface FTPReadable extends Readable {
+  lastModified?: Date;
+}
+interface FTPOptions extends AccessOptions {
+  cache?: FTPReadable;
+}
+//#endregion
+//#region ../../node_modules/get-uri/dist/http.d.ts
+type HttpOrHttpsModule = typeof http_ | typeof https;
+interface HttpReadableProps {
+  date?: number;
+  parsed?: URL;
+  redirects?: HttpReadable[];
+}
+interface HttpReadable extends Readable, HttpReadableProps {}
+interface HttpOptions extends https.RequestOptions {
+  cache?: HttpReadable;
+  http?: HttpOrHttpsModule;
+  redirects?: HttpReadable[];
+  maxRedirects?: number;
+}
+//#endregion
+//#region ../../node_modules/get-uri/dist/index.d.ts
+type Protocol$1<T> = T extends `${infer Protocol}:${infer _}` ? Protocol : never;
+type GetUriProtocol<T> = (parsed: URL, opts?: T) => Promise<Readable>;
+declare const protocols: {
+  data: GetUriProtocol<DataOptions>;
+  file: GetUriProtocol<FileOptions>;
+  ftp: GetUriProtocol<FTPOptions>;
+  http: GetUriProtocol<HttpOptions>;
+  https: GetUriProtocol<HttpOptions>;
+};
+type Protocols = typeof protocols;
+type ProtocolsOptions = { [P in keyof Protocols]: NonNullable<Parameters<Protocols[P]>[1]> };
+type ProtocolOpts<T> = { [P in keyof ProtocolsOptions]: Protocol$1<T> extends P ? ProtocolsOptions[P] : never }[keyof Protocols];
+//#endregion
+//#region ../../node_modules/degenerator/dist/degenerator.d.ts
+type DegeneratorName = string | RegExp;
+type DegeneratorNames = DegeneratorName[];
+//#endregion
+//#region ../../node_modules/degenerator/dist/compile.d.ts
+interface CompileOptions {
+  names?: DegeneratorNames;
+  filename?: string;
+  sandbox?: Context;
+}
+//#endregion
+//#region ../../node_modules/pac-resolver/dist/index.d.ts
+type PacResolverOptions = CompileOptions;
+//#endregion
+//#region ../../node_modules/pac-proxy-agent/dist/index.d.ts
+type Protocol<T> = T extends `pac+${infer P}:${infer _}` ? P : T extends `${infer P}:${infer _}` ? P : never;
+type PacProxyAgentOptions<T> = http.AgentOptions & PacResolverOptions & ProtocolOpts<`${Protocol<T>}:`> & HttpProxyAgentOptions<''> & HttpsProxyAgentOptions<''> & SocksProxyAgentOptions & {
+  fallbackToDirect?: boolean;
+};
+//#endregion
+//#region ../../node_modules/proxy-agent/dist/index.d.ts
+type GetProxyForUrlCallback = (url: string) => string | Promise<string>;
+/**
+ * Supported proxy types.
+ */
+type ProxyAgentOptions = HttpProxyAgentOptions<''> & HttpsProxyAgentOptions<''> & SocksProxyAgentOptions & PacProxyAgentOptions<''> & {
+  /**
+   * Default `http.Agent` instance to use when no proxy is
+   * configured for a request. Defaults to a new `http.Agent()`
+   * instance with the proxy agent options passed in.
+   */
+  httpAgent?: http.Agent;
+  /**
+   * Default `http.Agent` instance to use when no proxy is
+   * configured for a request. Defaults to a new `https.Agent()`
+   * instance with the proxy agent options passed in.
+   */
+  httpsAgent?: http.Agent;
+  /**
+   * A callback for dynamic provision of proxy for url.
+   * Defaults to standard proxy environment variables,
+   * see https://www.npmjs.com/package/proxy-from-env for details
+   */
+  getProxyForUrl?: GetProxyForUrlCallback;
+};
+/**
+ * Uses the appropriate `Agent` subclass based off of the "proxy"
+ * environment variables that are currently set.
+ *
+ * An LRU cache is used, to prevent unnecessary creation of proxy
+ * `http.Agent` instances.
+ */
+declare class ProxyAgent extends Agent {
+  /**
+   * Cache for `Agent` instances.
+   */
+  cache: LRUCache<string, Agent>;
+  connectOpts?: ProxyAgentOptions;
+  httpAgent: http.Agent;
+  httpsAgent: http.Agent;
+  getProxyForUrl: GetProxyForUrlCallback;
+  constructor(opts?: ProxyAgentOptions);
+  connect(req: http.ClientRequest, opts: AgentConnectOpts): Promise<http.Agent>;
+  destroy(): void;
+}
+declare namespace utils_d_exports {
+  export { DEFAULT_CONFIG_PATHS, ProxyConfiguration, RequestOptions$1 as RequestOptions, buildPath, execute, filterAndFormatGithubRemote, filterSensitiveInfoFromRepository, formatBytes, getApiHostForSite, getConfig, getGitHubEventPayload, getProxyAgent, getProxyUrl, getRequestBuilder, isFile, makeTerminalLink, maskString, normalizeRef, performSubCommand, pick, pluralize, recursivelyRemoveUndefinedValues, removeEmptyValues, removeUndefinedValues, resolveConfigFromFile, resolveConfigFromFileAndEnvironment, timedExecAsync };
+}
+declare const DEFAULT_CONFIG_PATHS: string[];
+type TerminalLink<URL extends string> = (strings: TemplateStringsArray) => string & {
+  targetUrl: URL;
+};
+declare const makeTerminalLink: <URL_1 extends string>(url: URL_1) => TerminalLink<URL_1>;
+declare const pick: <T extends Record<any, any>, K extends keyof T>(base: T, keys: K[]) => Partial<T>;
+declare const getConfig: (configPath: string) => Promise<Record<string, unknown> | undefined>;
+/**
+ * Applies configurations in this order of priority:
+ * environment > config file > base config
+ */
+declare const resolveConfigFromFileAndEnvironment: <T extends Record<string, unknown>, U extends Record<string, unknown>>(baseConfig: T, environment: U, params: {
+  configPath?: string | undefined;
+  defaultConfigPaths?: string[] | undefined;
+  configFromFileCallback?: ((configFromFile: any) => void) | undefined;
+}) => Promise<T & U>;
+declare const resolveConfigFromFile: <T>(baseConfig: T, params: {
+  configPath?: string;
+  defaultConfigPaths?: string[];
+}) => Promise<T>;
+type ProxyType = 'http' | 'https' | 'socks' | 'socks4' | 'socks4a' | 'socks5' | 'socks5h' | 'pac+data' | 'pac+file' | 'pac+ftp' | 'pac+http' | 'pac+https';
+interface ProxyConfiguration {
+  auth?: {
+    password: string;
+    username: string;
+  };
+  host?: string;
+  port?: number;
+  protocol: ProxyType;
+}
+declare const getProxyUrl: (options?: ProxyConfiguration) => string;
+interface RequestOptions$1 {
+  apiKey: string;
+  appKey?: string;
+  baseUrl: string;
+  headers?: Map<string, string>;
+  overrideUrl?: string;
+  proxyOpts?: ProxyConfiguration;
+}
+declare const getRequestBuilder: (options: RequestOptions$1) => RequestBuilder;
+declare const getProxyAgent: (proxyOpts?: ProxyConfiguration) => ProxyAgent;
+declare const getApiHostForSite: (site: string) => string;
+declare const buildPath: (...args: string[]) => string;
+declare const removeEmptyValues: (tags: SpanTags) => {};
+declare const removeUndefinedValues: <T extends {
+  [key: string]: unknown;
+}>(object: T) => T;
+declare const recursivelyRemoveUndefinedValues: <T extends Record<string, unknown>>(object: T) => Partial<T>;
+declare const normalizeRef: (ref: string | undefined) => string | undefined;
+declare const pluralize: (nb: number, singular: string, plural: string) => string;
+declare const performSubCommand: (command: CommandClass<BaseContext>, commandArgs: string[], context: BaseContext) => Promise<number>;
+declare const filterSensitiveInfoFromRepository: (repositoryUrl: string | undefined) => string | undefined;
+declare const filterAndFormatGithubRemote: (rawRemote: string | undefined) => string | undefined;
+declare const timedExecAsync: <I, O>(f: (input: I) => Promise<O>, input: I) => Promise<number>;
+/**
+ * Convert bytes to a formatted string in KB, MB, GB, etc.
+ * Note: Lambda documentation uses MB (instead of Mib) to refer to 1024 KB, so we follow that style here
+ * @param bytes
+ * @param decimals
+ */
+declare const formatBytes: (bytes: number, decimals?: number) => string;
+declare const maskString: (value?: string) => string;
+declare const execute: (cmd: string, cwd?: string) => Promise<{
+  stderr: string;
+  stdout: string;
+}>;
+type GitHubWebhookPayload = {
+  pull_request?: {
+    head?: {
+      sha: string;
+    };
+    base?: {
+      sha: string;
+    };
+    number?: number;
+  };
+};
+declare const getGitHubEventPayload: () => GitHubWebhookPayload | undefined;
+declare const isFile: (path: string) => boolean;
+//#endregion
+//#region ../base/dist/version.d.ts
+declare const cliVersion: string;
+/**
+ * Prints version in all commands, except version commands.
+ */
+declare const printVersion: () => void;
+//#endregion
+//#region src/cli.d.ts
+declare const BETA_COMMANDS: Set<string>;
+declare const cli: Cli<CommandContext>;
+//#endregion
+export { BETA_COMMANDS, cli, cliVersion, library_d_exports as gitMetadata, printVersion, utils_d_exports as utils };
+//# sourceMappingURL=bundle.d.ts.map