@hot-updater/cli-tools 0.28.0 → 0.29.1

package/dist/index.d.mts

@@ -0,0 +1,830 @@
+import { Readable } from "stream";
+import { Key as Key$1 } from "node:readline";
+import { Readable as Readable$1, Writable } from "node:stream";
+import { ConfigInput, Platform, RequiredDeep } from "@hot-updater/plugin-core";
+
+//#region src/BuildLogger.d.ts
+type LinePattern = string | RegExp;
+interface BuildLoggerConfig {
+  logPrefix: string;
+  /** Lines that should be surfaced in prompt output as important events. */
+  importantLogPatterns: LinePattern[];
+  /** Progress stages: stage index advances when corresponding output patterns are observed. */
+  progressStages: LinePattern[][];
+}
+declare class BuildLogger {
+  private readonly config;
+  private state;
+  private logWriter?;
+  private readonly promptProgress;
+  private readonly stageCount;
+  constructor(config: BuildLoggerConfig);
+  start(): Promise<void>;
+  processStream(input: Readable): Promise<void>;
+  private consumeProgressStream;
+  private processProgressLine;
+  stop(message?: string, success?: boolean): void;
+  writeError(error: unknown): void;
+  close(): Promise<void>;
+  private updateProgress;
+  private finishRemainingProgress;
+  private shouldLogLine;
+  private showLogFileLocation;
+}
+//#endregion
+//#region src/banner.d.ts
+declare const link: (url: string) => string;
+declare const banner: (version?: string) => string;
+declare const printBanner: (version?: string) => void;
+//#endregion
+//#region src/ConfigBuilder.d.ts
+type BuildType = "bare" | "rock" | "expo";
+type ImportInfo = {
+  pkg: string;
+  named?: string[];
+  defaultOrNamespace?: string;
+  sideEffect?: boolean;
+};
+type ProviderConfig = {
+  imports: ImportInfo[];
+  configString: string;
+};
+interface IConfigBuilder {
+  /** Sets the build type ('bare' or 'rock' or 'expo') and adds necessary build imports. */
+  setBuildType(buildType: BuildType): this;
+  /** Sets the storage configuration and adds its required imports. */
+  setStorage(storageConfig: ProviderConfig): this;
+  /** Sets the database configuration and adds its required imports. */
+  setDatabase(databaseConfig: ProviderConfig): this;
+  /** Sets the intermediate code block to be placed between imports and defineConfig. */
+  setIntermediateCode(code: string): this;
+  /** Assembles and returns the final configuration string. */
+  getResult(): string;
+}
+declare class ConfigBuilder implements IConfigBuilder {
+  private buildType;
+  private storageInfo;
+  private databaseInfo;
+  private intermediateCode;
+  private collectedImports;
+  constructor();
+  addImport(info: ImportInfo): this;
+  private addImports;
+  private generateImportStatements;
+  private generateBuildConfigString;
+  setBuildType(buildType: BuildType): this;
+  setStorage(storageConfig: ProviderConfig): this;
+  setDatabase(databaseConfig: ProviderConfig): this;
+  setIntermediateCode(code: string): this;
+  getResult(): string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/types.d.ts
+type Formatter = (input: string | number | null | undefined) => string;
+interface Colors {
+  isColorSupported: boolean;
+  reset: Formatter;
+  bold: Formatter;
+  dim: Formatter;
+  italic: Formatter;
+  underline: Formatter;
+  inverse: Formatter;
+  hidden: Formatter;
+  strikethrough: Formatter;
+  black: Formatter;
+  red: Formatter;
+  green: Formatter;
+  yellow: Formatter;
+  blue: Formatter;
+  magenta: Formatter;
+  cyan: Formatter;
+  white: Formatter;
+  gray: Formatter;
+  bgBlack: Formatter;
+  bgRed: Formatter;
+  bgGreen: Formatter;
+  bgYellow: Formatter;
+  bgBlue: Formatter;
+  bgMagenta: Formatter;
+  bgCyan: Formatter;
+  bgWhite: Formatter;
+  blackBright: Formatter;
+  redBright: Formatter;
+  greenBright: Formatter;
+  yellowBright: Formatter;
+  blueBright: Formatter;
+  magentaBright: Formatter;
+  cyanBright: Formatter;
+  whiteBright: Formatter;
+  bgBlackBright: Formatter;
+  bgRedBright: Formatter;
+  bgGreenBright: Formatter;
+  bgYellowBright: Formatter;
+  bgBlueBright: Formatter;
+  bgMagentaBright: Formatter;
+  bgCyanBright: Formatter;
+  bgWhiteBright: Formatter;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.d.ts
+declare const picocolors: Colors & {
+  createColors: (enabled?: boolean) => Colors;
+};
+//#endregion
+//#region src/copyDirToTmp.d.ts
+declare const copyDirToTmp: (dir: string, childDirname?: string) => Promise<{
+  tmpDir: string;
+  removeTmpDir: () => Promise<void>;
+}>;
+//#endregion
+//#region src/createTarBr.d.ts
+declare const createTarBrTargetFiles: ({
+  outfile,
+  targetFiles
+}: {
+  targetFiles: {
+    path: string;
+    name: string;
+  }[];
+  outfile: string;
+}) => Promise<string>;
+declare const createTarBr: ({
+  outfile,
+  targetDir,
+  excludeExts
+}: {
+  targetDir: string;
+  outfile: string;
+  excludeExts?: string[];
+}) => Promise<string>;
+//#endregion
+//#region src/createTarGz.d.ts
+declare const createTarGzTargetFiles: ({
+  outfile,
+  targetFiles
+}: {
+  targetFiles: {
+    path: string;
+    name: string;
+  }[];
+  outfile: string;
+}) => Promise<string>;
+declare const createTarGz: ({
+  outfile,
+  targetDir,
+  excludeExts
+}: {
+  targetDir: string;
+  outfile: string;
+  excludeExts?: string[];
+}) => Promise<string>;
+//#endregion
+//#region src/createZip.d.ts
+declare const createZipTargetFiles: ({
+  outfile,
+  targetFiles
+}: {
+  targetFiles: {
+    path: string;
+    name: string;
+  }[];
+  outfile: string;
+}) => Promise<string>;
+declare const createZip: ({
+  outfile,
+  targetDir,
+  excludeExts
+}: {
+  targetDir: string;
+  outfile: string;
+  excludeExts?: string[];
+}) => Promise<string>;
+//#endregion
+//#region src/crypto.d.ts
+declare const encryptJson: (jsonData: Record<string, any>, secretKey: string) => string;
+declare const decryptJson: <T>(encryptedData: string, secretKey: string) => T;
+//#endregion
+//#region src/cwd.d.ts
+declare const getCwd: () => string;
+//#endregion
+//#region src/ensureInstallPackages.d.ts
+declare const ensureInstallPackages: (packages: {
+  dependencies?: string[];
+  devDependencies?: string[];
+}, options?: {
+  versionResolver?: (pkg: string) => string;
+}) => Promise<void>;
+//#endregion
+//#region src/getAndroidSdkPath.d.ts
+declare function getAndroidSdkPath(): string;
+//#endregion
+//#region src/getPackageManager.d.ts
+declare const getPackageManager: () => string;
+//#endregion
+//#region src/getReactNativeMetadatas.d.ts
+interface ReactNativeMetadata {
+  packagePath: string;
+  versionRaw: string;
+  version: {
+    major: number;
+    minor: number;
+    patch?: number;
+  };
+}
+declare const getReactNativeMetadatas: (cwd?: string) => ReactNativeMetadata;
+//#endregion
+//#region src/LogWriter.d.ts
+type HotUpdaterLogWriter = {
+  logFilePath: string | null;
+  writeStream: (input: Readable) => Promise<void>;
+  writeError: (error: unknown) => void;
+  close: () => Promise<void>;
+};
+declare const stripAnsi: (value: string) => string;
+declare const createLogWriter: ({
+  prefix,
+  logFilePath
+}: {
+  prefix: string;
+  logFilePath?: string;
+}) => Promise<HotUpdaterLogWriter>;
+//#endregion
+//#region src/loadConfig.d.ts
+type HotUpdaterConfigOptions = {
+  platform: Platform;
+  channel: string;
+} | null;
+type ConfigResponse = RequiredDeep<ConfigInput>;
+declare const loadConfig: (options: HotUpdaterConfigOptions) => Promise<ConfigResponse>;
+//#endregion
+//#region src/log.d.ts
+declare const log: {
+  normal: (message: string | number | null | undefined) => void;
+  success: (message: string | number | null | undefined) => void;
+  info: (message: string | number | null | undefined) => void;
+  error: (message: string | number | null | undefined) => void;
+  warn: (message: string | number | null | undefined) => void;
+  debug: (message: string | number | null | undefined) => void;
+};
+//#endregion
+//#region src/makeEnv.d.ts
+type EnvVarValue = string | {
+  comment: string;
+  value: string;
+};
+declare const makeEnv: (newEnvVars: Record<string, EnvVarValue>, filePath?: string) => Promise<string>;
+//#endregion
+//#region ../../node_modules/.pnpm/@clack+core@1.0.1/node_modules/@clack/core/dist/index.d.mts
+declare const actions: readonly ["up", "down", "left", "right", "space", "enter", "cancel"];
+type Action = (typeof actions)[number];
+/** Global settings for Clack programs, stored in memory */
+interface InternalClackSettings {
+  actions: Set<Action>;
+  aliases: Map<string, Action>;
+  messages: {
+    cancel: string;
+    error: string;
+  };
+  withGuide: boolean;
+}
+declare const settings: InternalClackSettings;
+interface ClackSettings {
+  /**
+   * Set custom global aliases for the default actions.
+   * This will not overwrite existing aliases, it will only add new ones!
+   *
+   * @param aliases - An object that maps aliases to actions
+   * @default { k: 'up', j: 'down', h: 'left', l: 'right', '\x03': 'cancel', 'escape': 'cancel' }
+   */
+  aliases?: Record<string, Action>;
+  /**
+   * Custom messages for prompts
+   */
+  messages?: {
+    /**
+     * Custom message to display when a spinner is cancelled
+     * @default "Canceled"
+     */
+    cancel?: string;
+    /**
+     * Custom message to display when a spinner encounters an error
+     * @default "Something went wrong"
+     */
+    error?: string;
+  };
+  withGuide?: boolean;
+}
+declare function updateSettings(updates: ClackSettings): void;
+/**
+ * The state of the prompt
+ */
+type ClackState = 'initial' | 'active' | 'cancel' | 'submit' | 'error';
+/**
+ * Typed event emitter for clack
+ */
+interface ClackEvents<TValue> {
+  initial: (value?: any) => void;
+  active: (value?: any) => void;
+  cancel: (value?: any) => void;
+  submit: (value?: any) => void;
+  error: (value?: any) => void;
+  cursor: (key?: Action) => void;
+  key: (key: string | undefined, info: Key$1) => void;
+  value: (value?: TValue) => void;
+  userInput: (value: string) => void;
+  confirm: (value?: boolean) => void;
+  finalize: () => void;
+  beforePrompt: () => void;
+}
+interface PromptOptions<TValue, Self extends Prompt<TValue>> {
+  render(this: Omit<Self, 'prompt'>): string | undefined;
+  initialValue?: any;
+  initialUserInput?: string;
+  validate?: ((value: TValue | undefined) => string | Error | undefined) | undefined;
+  input?: Readable$1;
+  output?: Writable;
+  debug?: boolean;
+  signal?: AbortSignal;
+}
+declare class Prompt<TValue> {
+  protected input: Readable$1;
+  protected output: Writable;
+  private _abortSignal?;
+  private rl;
+  private opts;
+  private _render;
+  private _track;
+  private _prevFrame;
+  private _subscribers;
+  protected _cursor: number;
+  state: ClackState;
+  error: string;
+  value: TValue | undefined;
+  userInput: string;
+  constructor(options: PromptOptions<TValue, Prompt<TValue>>, trackValue?: boolean);
+  /**
+   * Unsubscribe all listeners
+   */
+  protected unsubscribe(): void;
+  /**
+   * Set a subscriber with opts
+   * @param event - The event name
+   */
+  private setSubscriber;
+  /**
+   * Subscribe to an event
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  on<T extends keyof ClackEvents<TValue>>(event: T, cb: ClackEvents<TValue>[T]): void;
+  /**
+   * Subscribe to an event once
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  once<T extends keyof ClackEvents<TValue>>(event: T, cb: ClackEvents<TValue>[T]): void;
+  /**
+   * Emit an event with data
+   * @param event - The event name
+   * @param data - The data to pass to the callback
+   */
+  emit<T extends keyof ClackEvents<TValue>>(event: T, ...data: Parameters<ClackEvents<TValue>[T]>): void;
+  prompt(): Promise<symbol | TValue | undefined>;
+  protected _isActionKey(char: string | undefined, _key: Key$1): boolean;
+  protected _setValue(value: TValue | undefined): void;
+  protected _setUserInput(value: string | undefined, write?: boolean): void;
+  protected _clearUserInput(): void;
+  private onKeypress;
+  protected close(): void;
+  private restoreCursor;
+  private render;
+}
+interface OptionLike$1 {
+  value: unknown;
+  label?: string;
+  disabled?: boolean;
+}
+type FilterFunction<T extends OptionLike$1> = (search: string, opt: T) => boolean;
+interface AutocompleteOptions$1<T extends OptionLike$1> extends PromptOptions<T['value'] | T['value'][], AutocompletePrompt<T>> {
+  options: T[] | ((this: AutocompletePrompt<T>) => T[]);
+  filter?: FilterFunction<T>;
+  multiple?: boolean;
+}
+declare class AutocompletePrompt<T extends OptionLike$1> extends Prompt<T['value'] | T['value'][]> {
+  #private;
+  filteredOptions: T[];
+  multiple: boolean;
+  isNavigating: boolean;
+  selectedValues: Array<T['value']>;
+  focusedValue: T['value'] | undefined;
+  get cursor(): number;
+  get userInputWithCursor(): string;
+  get options(): T[];
+  constructor(opts: AutocompleteOptions$1<T>);
+  protected _isActionKey(char: string | undefined, key: Key$1): boolean;
+  deselectAll(): void;
+  toggleSelected(value: T['value']): void;
+}
+declare function isCancel(value: unknown): value is symbol;
+declare namespace index_d_exports {
+  export { AutocompleteMultiSelectOptions, AutocompleteOptions, BoxAlignment, BoxOptions, ClackSettings, CommonOptions, ConfirmOptions, GroupMultiSelectOptions, LimitOptionsParams, LogMessageOptions, MultiSelectOptions, NoteOptions, Option, PasswordOptions, PathOptions, ProgressOptions, ProgressResult, PromptGroup, PromptGroupAwaitedReturn, PromptGroupOptions, S_BAR, S_BAR_END, S_BAR_END_RIGHT, S_BAR_H, S_BAR_START, S_BAR_START_RIGHT, S_CHECKBOX_ACTIVE, S_CHECKBOX_INACTIVE, S_CHECKBOX_SELECTED, S_CONNECT_LEFT, S_CORNER_BOTTOM_LEFT, S_CORNER_BOTTOM_RIGHT, S_CORNER_TOP_LEFT, S_CORNER_TOP_RIGHT, S_ERROR, S_INFO, S_PASSWORD_MASK, S_RADIO_ACTIVE, S_RADIO_INACTIVE, S_STEP_ACTIVE, S_STEP_CANCEL, S_STEP_ERROR, S_STEP_SUBMIT, S_SUCCESS, S_WARN, SelectKeyOptions, SelectOptions, SpinnerOptions, SpinnerResult, Task, TaskLogCompletionOptions, TaskLogMessageOptions, TaskLogOptions, TextOptions, autocomplete, autocompleteMultiselect, box, cancel, confirm, group, groupMultiselect, intro, isCI, isCancel, isTTY, limitOptions, log$1 as log, multiselect, note, outro, password, path, progress, select, selectKey, settings, spinner, stream, symbol, symbolBar, taskLog, tasks, text, unicode, unicodeOr, updateSettings };
+}
+declare const unicode: boolean;
+declare const isCI: () => boolean;
+declare const isTTY: (output: Writable) => boolean;
+declare const unicodeOr: (c: string, fallback: string) => string;
+declare const S_STEP_ACTIVE: string;
+declare const S_STEP_CANCEL: string;
+declare const S_STEP_ERROR: string;
+declare const S_STEP_SUBMIT: string;
+declare const S_BAR_START: string;
+declare const S_BAR: string;
+declare const S_BAR_END: string;
+declare const S_BAR_START_RIGHT: string;
+declare const S_BAR_END_RIGHT: string;
+declare const S_RADIO_ACTIVE: string;
+declare const S_RADIO_INACTIVE: string;
+declare const S_CHECKBOX_ACTIVE: string;
+declare const S_CHECKBOX_SELECTED: string;
+declare const S_CHECKBOX_INACTIVE: string;
+declare const S_PASSWORD_MASK: string;
+declare const S_BAR_H: string;
+declare const S_CORNER_TOP_RIGHT: string;
+declare const S_CONNECT_LEFT: string;
+declare const S_CORNER_BOTTOM_RIGHT: string;
+declare const S_CORNER_BOTTOM_LEFT: string;
+declare const S_CORNER_TOP_LEFT: string;
+declare const S_INFO: string;
+declare const S_SUCCESS: string;
+declare const S_WARN: string;
+declare const S_ERROR: string;
+declare const symbol: (state: ClackState) => string;
+declare const symbolBar: (state: ClackState) => string;
+interface CommonOptions {
+  input?: Readable$1;
+  output?: Writable;
+  signal?: AbortSignal;
+  withGuide?: boolean;
+}
+type Primitive = Readonly<string | boolean | number>;
+type Option<Value> = Value extends Primitive ? {
+  /**
+   * Internal data for this option.
+   */
+  value: Value;
+  /**
+   * The optional, user-facing text for this option.
+   *
+   * By default, the `value` is converted to a string.
+   */
+  label?: string;
+  /**
+   * An optional hint to display to the user when
+   * this option might be selected.
+   *
+   * By default, no `hint` is displayed.
+   */
+  hint?: string;
+  /**
+   * Whether this option is disabled.
+   * Disabled options are visible but cannot be selected.
+   *
+   * By default, options are not disabled.
+   */
+  disabled?: boolean;
+} : {
+  /**
+   * Internal data for this option.
+   */
+  value: Value;
+  /**
+   * Required. The user-facing text for this option.
+   */
+  label: string;
+  /**
+   * An optional hint to display to the user when
+   * this option might be selected.
+   *
+   * By default, no `hint` is displayed.
+   */
+  hint?: string;
+  /**
+   * Whether this option is disabled.
+   * Disabled options are visible but cannot be selected.
+   *
+   * By default, options are not disabled.
+   */
+  disabled?: boolean;
+};
+interface SelectOptions<Value> extends CommonOptions {
+  message: string;
+  options: Option<Value>[];
+  initialValue?: Value;
+  maxItems?: number;
+}
+declare const select: <Value>(opts: SelectOptions<Value>) => Promise<Value | symbol>;
+interface AutocompleteSharedOptions<Value> extends CommonOptions {
+  /**
+   * The message to display to the user.
+   */
+  message: string;
+  /**
+   * Available options for the autocomplete prompt.
+   */
+  options: Option<Value>[] | ((this: AutocompletePrompt<Option<Value>>) => Option<Value>[]);
+  /**
+   * Maximum number of items to display at once.
+   */
+  maxItems?: number;
+  /**
+   * Placeholder text to display when no input is provided.
+   */
+  placeholder?: string;
+  /**
+   * Validates the value
+   */
+  validate?: (value: Value | Value[] | undefined) => string | Error | undefined;
+  /**
+   * Custom filter function to match options against search input.
+   * If not provided, a default filter that matches label, hint, and value is used.
+   */
+  filter?: (search: string, option: Option<Value>) => boolean;
+}
+interface AutocompleteOptions<Value> extends AutocompleteSharedOptions<Value> {
+  /**
+   * The initial selected value.
+   */
+  initialValue?: Value;
+  /**
+   * The initial user input
+   */
+  initialUserInput?: string;
+}
+declare const autocomplete: <Value>(opts: AutocompleteOptions<Value>) => Promise<Value | symbol>;
+interface AutocompleteMultiSelectOptions<Value> extends AutocompleteSharedOptions<Value> {
+  /**
+   * The initial selected values
+   */
+  initialValues?: Value[];
+  /**
+   * If true, at least one option must be selected
+   */
+  required?: boolean;
+}
+/**
+ * Integrated autocomplete multiselect - combines type-ahead filtering with multiselect in one UI
+ */
+declare const autocompleteMultiselect: <Value>(opts: AutocompleteMultiSelectOptions<Value>) => Promise<Value[] | symbol>;
+type BoxAlignment = 'left' | 'center' | 'right';
+interface BoxOptions extends CommonOptions {
+  contentAlign?: BoxAlignment;
+  titleAlign?: BoxAlignment;
+  width?: number | 'auto';
+  titlePadding?: number;
+  contentPadding?: number;
+  rounded?: boolean;
+  formatBorder?: (text: string) => string;
+}
+declare const box: (message?: string, title?: string, opts?: BoxOptions) => void;
+interface ConfirmOptions extends CommonOptions {
+  message: string;
+  active?: string;
+  inactive?: string;
+  initialValue?: boolean;
+  vertical?: boolean;
+}
+declare const confirm: (opts: ConfirmOptions) => Promise<boolean | symbol>;
+type Prettify<T> = { [P in keyof T]: T[P] } & {};
+type PromptGroupAwaitedReturn<T> = { [P in keyof T]: Exclude<Awaited<T[P]>, symbol> };
+interface PromptGroupOptions<T> {
+  /**
+   * Control how the group can be canceled
+   * if one of the prompts is canceled.
+   */
+  onCancel?: (opts: {
+    results: Prettify<Partial<PromptGroupAwaitedReturn<T>>>;
+  }) => void;
+}
+type PromptGroup<T> = { [P in keyof T]: (opts: {
+  results: Prettify<Partial<PromptGroupAwaitedReturn<Omit<T, P>>>>;
+}) => undefined | Promise<T[P] | undefined> };
+/**
+ * Define a group of prompts to be displayed
+ * and return a results of objects within the group
+ */
+declare const group: <T>(prompts: PromptGroup<T>, opts?: PromptGroupOptions<T>) => Promise<Prettify<PromptGroupAwaitedReturn<T>>>;
+interface GroupMultiSelectOptions<Value> extends CommonOptions {
+  message: string;
+  options: Record<string, Option<Value>[]>;
+  initialValues?: Value[];
+  required?: boolean;
+  cursorAt?: Value;
+  selectableGroups?: boolean;
+  groupSpacing?: number;
+}
+declare const groupMultiselect: <Value>(opts: GroupMultiSelectOptions<Value>) => Promise<Value[] | symbol>;
+interface LimitOptionsParams<TOption> extends CommonOptions {
+  options: TOption[];
+  maxItems: number | undefined;
+  cursor: number;
+  style: (option: TOption, active: boolean) => string;
+  columnPadding?: number;
+  rowPadding?: number;
+}
+declare const limitOptions: <TOption>(params: LimitOptionsParams<TOption>) => string[];
+interface LogMessageOptions extends CommonOptions {
+  symbol?: string;
+  spacing?: number;
+  secondarySymbol?: string;
+}
+declare const log$1: {
+  message: (message?: string | string[], {
+    symbol,
+    secondarySymbol,
+    output,
+    spacing,
+    withGuide
+  }?: LogMessageOptions) => void;
+  info: (message: string, opts?: LogMessageOptions) => void;
+  success: (message: string, opts?: LogMessageOptions) => void;
+  step: (message: string, opts?: LogMessageOptions) => void;
+  warn: (message: string, opts?: LogMessageOptions) => void; /** alias for `log.warn()`. */
+  warning: (message: string, opts?: LogMessageOptions) => void;
+  error: (message: string, opts?: LogMessageOptions) => void;
+};
+declare const cancel: (message?: string, opts?: CommonOptions) => void;
+declare const intro: (title?: string, opts?: CommonOptions) => void;
+declare const outro: (message?: string, opts?: CommonOptions) => void;
+interface MultiSelectOptions<Value> extends CommonOptions {
+  message: string;
+  options: Option<Value>[];
+  initialValues?: Value[];
+  maxItems?: number;
+  required?: boolean;
+  cursorAt?: Value;
+}
+declare const multiselect: <Value>(opts: MultiSelectOptions<Value>) => Promise<Value[] | symbol>;
+type FormatFn = (line: string) => string;
+interface NoteOptions extends CommonOptions {
+  format?: FormatFn;
+}
+declare const note: (message?: string, title?: string, opts?: NoteOptions) => void;
+interface PasswordOptions extends CommonOptions {
+  message: string;
+  mask?: string;
+  validate?: (value: string | undefined) => string | Error | undefined;
+  clearOnError?: boolean;
+}
+declare const password: (opts: PasswordOptions) => Promise<string | symbol>;
+interface PathOptions extends CommonOptions {
+  root?: string;
+  directory?: boolean;
+  initialValue?: string;
+  message: string;
+  validate?: (value: string | undefined) => string | Error | undefined;
+}
+declare const path: (opts: PathOptions) => Promise<string | symbol>;
+interface SpinnerOptions extends CommonOptions {
+  indicator?: 'dots' | 'timer';
+  onCancel?: () => void;
+  cancelMessage?: string;
+  errorMessage?: string;
+  frames?: string[];
+  delay?: number;
+  styleFrame?: (frame: string) => string;
+}
+interface SpinnerResult {
+  start(msg?: string): void;
+  stop(msg?: string): void;
+  cancel(msg?: string): void;
+  error(msg?: string): void;
+  message(msg?: string): void;
+  clear(): void;
+  readonly isCancelled: boolean;
+}
+declare const spinner: ({
+  indicator,
+  onCancel,
+  output,
+  cancelMessage,
+  errorMessage,
+  frames,
+  delay,
+  signal,
+  ...opts
+}?: SpinnerOptions) => SpinnerResult;
+interface ProgressOptions extends SpinnerOptions {
+  style?: 'light' | 'heavy' | 'block';
+  max?: number;
+  size?: number;
+}
+interface ProgressResult extends SpinnerResult {
+  advance(step?: number, msg?: string): void;
+}
+declare function progress({
+  style,
+  max: userMax,
+  size: userSize,
+  ...spinnerOptions
+}?: ProgressOptions): ProgressResult;
+interface SelectKeyOptions<Value extends string> extends CommonOptions {
+  message: string;
+  options: Option<Value>[];
+  initialValue?: Value;
+  caseSensitive?: boolean;
+}
+declare const selectKey: <Value extends string>(opts: SelectKeyOptions<Value>) => Promise<Value | symbol>;
+declare const stream: {
+  message: (iterable: Iterable<string> | AsyncIterable<string>, {
+    symbol
+  }?: LogMessageOptions) => Promise<void>;
+  info: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+  success: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+  step: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+  warn: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>; /** alias for `log.warn()`. */
+  warning: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+  error: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+};
+type Task = {
+  /**
+   * Task title
+   */
+  title: string;
+  /**
+   * Task function
+   */
+  task: (message: (string: string) => void) => string | Promise<string> | void | Promise<void>;
+  /**
+   * If enabled === false the task will be skipped
+   */
+  enabled?: boolean;
+};
+/**
+ * Define a group of tasks to be executed
+ */
+declare const tasks: (tasks: Task[], opts?: CommonOptions) => Promise<void>;
+interface TaskLogOptions extends CommonOptions {
+  title: string;
+  limit?: number;
+  spacing?: number;
+  retainLog?: boolean;
+}
+interface TaskLogMessageOptions {
+  raw?: boolean;
+}
+interface TaskLogCompletionOptions {
+  showLog?: boolean;
+}
+/**
+ * Renders a log which clears on success and remains on failure
+ */
+declare const taskLog: (opts: TaskLogOptions) => {
+  message(msg: string, mopts?: TaskLogMessageOptions): void;
+  group(name: string): {
+    message(msg: string, mopts?: TaskLogMessageOptions): void;
+    error(message: string): void;
+    success(message: string): void;
+  };
+  error(message: string, opts?: TaskLogCompletionOptions): void;
+  success(message: string, opts?: TaskLogCompletionOptions): void;
+};
+interface TextOptions extends CommonOptions {
+  message: string;
+  placeholder?: string;
+  defaultValue?: string;
+  initialValue?: string;
+  validate?: (value: string | undefined) => string | Error | undefined;
+}
+declare const text: (opts: TextOptions) => Promise<string | symbol>;
+//#endregion
+//#region src/prompts.d.ts
+type PromptProgress = ReturnType<typeof progress>;
+type PromptSpinner = ReturnType<typeof spinner>;
+//#endregion
+//#region src/resolvePackageVersion.d.ts
+declare const HOT_UPDATER_SERVER_PACKAGE_VERSION_ENV = "HOT_UPDATER_SERVER_PACKAGE_VERSION";
+declare const resolvePackageVersion: (packageName: string, options?: {
+  searchFrom?: string;
+}) => string;
+declare const resolveHotUpdaterServerVersion: (currentPackageName: string, options?: {
+  searchFrom?: string;
+}) => string;
+//#endregion
+//#region src/transformEnv.d.ts
+declare const transformEnv: <T extends Record<string, string>>(filename: string, env: T) => string;
+//#endregion
+//#region src/transformTemplate.d.ts
+type ExtractPlaceholders<T extends string> = T extends `${infer _Start}%%${infer Key}%%${infer Rest}` ? Key | ExtractPlaceholders<Rest> : never;
+type TransformTemplateArgs<T extends string> = { [Key in ExtractPlaceholders<T>]: string };
+/**
+ * Replaces placeholders in the format %%key%% in a template string with values from the values object.
+ * Uses generic type T to automatically infer placeholder keys from the template string to ensure type safety.
+ *
+ * @example
+ * const str = "Hello %%name%%, you are %%age%% years old."
+ * const result = transformTemplate(str, { name: "John", age: "20" })
+ * // Result: "Hello John, you are 20 years old."
+ */
+declare function transformTemplate<T extends string>(templateString: T, values: TransformTemplateArgs<T>): string;
+//#endregion
+export { BuildLogger, BuildLoggerConfig, BuildType, ConfigBuilder, ConfigResponse, HOT_UPDATER_SERVER_PACKAGE_VERSION_ENV, HotUpdaterConfigOptions, HotUpdaterLogWriter, IConfigBuilder, ImportInfo, PromptProgress, PromptSpinner, ProviderConfig, ReactNativeMetadata, banner, picocolors as colors, copyDirToTmp, createLogWriter, createTarBr, createTarBrTargetFiles, createTarGz, createTarGzTargetFiles, createZip, createZipTargetFiles, decryptJson, encryptJson, ensureInstallPackages, getAndroidSdkPath, getCwd, getPackageManager, getReactNativeMetadatas, link, loadConfig, log, makeEnv, index_d_exports as p, printBanner, resolveHotUpdaterServerVersion, resolvePackageVersion, stripAnsi, transformEnv, transformTemplate };