@shopify/cli-kit 3.0.10 → 3.0.13

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { Listr, ListrTaskWrapper, ListrDefaultRenderer, ListrTask } from 'listr2';
 import { AbortSignal, AbortController } from 'abort-controller';
-import * as execa from 'execa';
 import { Writable } from 'node:stream';
 import { camelCase, paramCase, snakeCase, constantCase } from 'change-case';
 import * as pathe from 'pathe';
@@ -69,6 +68,280 @@ declare namespace ui {
   };
 }
 
+declare const dependencyManager: readonly ["yarn", "npm", "pnpm"];
+declare type DependencyManager = typeof dependencyManager[number];
+declare const PackageJsonNotFoundError: (directory: string) => Abort;
+/**
+ * Returns the dependency manager used to run the create workflow.
+ * @param env {Object} The environment variables of the process in which the CLI runs.
+ * @returns The dependency manager
+ */
+declare function dependencyManagerUsedForCreating(env?: NodeJS.ProcessEnv): DependencyManager;
+interface InstallNPMDependenciesRecursivelyOptions {
+    /**
+     * The dependency manager to use to install the dependencies.
+     */
+    dependencyManager: DependencyManager;
+    /**
+     * The directory from where we'll find package.json's recursively
+     */
+    directory: string;
+    /**
+     * Specifies the maximum depth of the glob search.
+     */
+    deep?: number;
+}
+/**
+ * This function traverses down a directory tree to find directories containing a package.json
+ * and installs the dependencies if needed. To know if it's needed, it uses the "check" command
+ * provided by dependency managers.
+ * @param options {InstallNPMDependenciesRecursivelyOptions} Options to install dependencies recursively.
+ */
+declare function installNPMDependenciesRecursively(options: InstallNPMDependenciesRecursivelyOptions): Promise<void>;
+/**
+ * Installs the dependencies in the given directory.
+ * @param directory {string} The directory that contains the package.json
+ * @param dependencyManager {DependencyManager} The dependency manager to use to install the dependencies.
+ * @param stdout {Writable} Standard output stream.
+ * @param stderr {Writable} Standard error stream.
+ * @param signal {AbortSignal} Abort signal.
+ * @returns stderr {Writable} Standard error stream.
+ */
+declare function install(directory: string, dependencyManager: DependencyManager, stdout?: Writable, stderr?: Writable, signal?: AbortSignal): Promise<void>;
+/**
+ * Returns the name of the package configured in its package.json
+ * @param packageJsonPath {string} Path to the package.json file
+ * @returns A promise that resolves with the name.
+ */
+declare function getPackageName(packageJsonPath: string): Promise<string>;
+/**
+ * Returns the list of production and dev dependencies of a package.json
+ * @param packageJsonPath {string} Path to the package.json file
+ * @returns A promise that resolves with the list of dependencies.
+ */
+declare function getDependencies(packageJsonPath: string): Promise<{
+    [key: string]: string;
+}>;
+declare function checkForNewVersion(dependency: string, currentVersion: string): Promise<string | undefined>;
+declare function getOutputUpdateCLIReminder(dependencyManager: DependencyManager, packages?: string[]): string;
+declare type DependencyType = 'dev' | 'prod' | 'peer';
+interface AddNPMDependenciesIfNeededOptions {
+    /** How dependencies should be added */
+    type: DependencyType;
+    /** The dependency manager to use to add dependencies */
+    dependencyManager: DependencyManager;
+    /** The directory that contains the package.json where dependencies will be added */
+    directory: string;
+    /** Standard output coming from the underlying installation process */
+    stdout?: Writable;
+    /** Standard error coming from the underlying installation process */
+    stderr?: Writable;
+    /** Abort signal to stop the process */
+    signal?: AbortSignal;
+}
+/**
+ * Adds dependencies to a Node project (i.e. a project that has a package.json)
+ * @param dependencies {string[]} List of dependencies to be added.
+ * @param options {AddNPMDependenciesIfNeededOptions} Options for adding dependencies.
+ */
+declare function addNPMDependenciesIfNeeded(dependencies: string[], options: AddNPMDependenciesIfNeededOptions): Promise<void>;
+
+declare const dependency_dependencyManager: typeof dependencyManager;
+type dependency_DependencyManager = DependencyManager;
+declare const dependency_PackageJsonNotFoundError: typeof PackageJsonNotFoundError;
+declare const dependency_dependencyManagerUsedForCreating: typeof dependencyManagerUsedForCreating;
+declare const dependency_installNPMDependenciesRecursively: typeof installNPMDependenciesRecursively;
+declare const dependency_install: typeof install;
+declare const dependency_getPackageName: typeof getPackageName;
+declare const dependency_getDependencies: typeof getDependencies;
+declare const dependency_checkForNewVersion: typeof checkForNewVersion;
+declare const dependency_getOutputUpdateCLIReminder: typeof getOutputUpdateCLIReminder;
+declare const dependency_addNPMDependenciesIfNeeded: typeof addNPMDependenciesIfNeeded;
+declare namespace dependency {
+  export {
+    dependency_dependencyManager as dependencyManager,
+    dependency_DependencyManager as DependencyManager,
+    dependency_PackageJsonNotFoundError as PackageJsonNotFoundError,
+    dependency_dependencyManagerUsedForCreating as dependencyManagerUsedForCreating,
+    dependency_installNPMDependenciesRecursively as installNPMDependenciesRecursively,
+    dependency_install as install,
+    dependency_getPackageName as getPackageName,
+    dependency_getDependencies as getDependencies,
+    dependency_checkForNewVersion as checkForNewVersion,
+    dependency_getOutputUpdateCLIReminder as getOutputUpdateCLIReminder,
+    dependency_addNPMDependenciesIfNeeded as addNPMDependenciesIfNeeded,
+  };
+}
+
+declare enum ContentTokenType {
+    Raw = 0,
+    Command = 1,
+    Json = 2,
+    Path = 3,
+    Link = 4,
+    Heading = 5,
+    SubHeading = 6,
+    Italic = 7,
+    ErrorText = 8,
+    Yellow = 9,
+    Cyan = 10,
+    Magenta = 11,
+    Green = 12
+}
+interface ContentMetadata {
+    link?: string;
+}
+declare class ContentToken {
+    type: ContentTokenType;
+    value: Message;
+    metadata: ContentMetadata;
+    constructor(value: Message, metadata: ContentMetadata | undefined, type: ContentTokenType);
+}
+declare const token: {
+    raw: (value: Message) => ContentToken;
+    genericShellCommand: (value: Message) => ContentToken;
+    json: (value: any) => ContentToken;
+    path: (value: Message) => ContentToken;
+    link: (value: Message, link: string) => ContentToken;
+    heading: (value: Message) => ContentToken;
+    subheading: (value: Message) => ContentToken;
+    italic: (value: Message) => ContentToken;
+    errorText: (value: Message) => ContentToken;
+    cyan: (value: Message) => ContentToken;
+    yellow: (value: Message) => ContentToken;
+    magenta: (value: Message) => ContentToken;
+    green: (value: Message) => ContentToken;
+    packagejsonScript: (dependencyManager: DependencyManager, scriptName: string, ...scriptArgs: string[]) => ContentToken;
+    successIcon: () => ContentToken;
+    failIcon: () => ContentToken;
+};
+declare class TokenizedString {
+    value: string;
+    constructor(value: string);
+}
+declare type Message = string | TokenizedString;
+declare function content(strings: TemplateStringsArray, ...keys: (ContentToken | string)[]): TokenizedString;
+/** Log levels */
+declare type LogLevel = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'silent';
+/**
+ *
+ * @returns {LogLevel} It returns the log level set by the user.
+ */
+declare const currentLogLevel: () => LogLevel;
+declare const shouldOutput: (logLevel: LogLevel) => boolean;
+/**
+ * Ouputs information to the user. This is akin to "console.log"
+ * Info messages don't get additional formatting.
+ * Note: Info messages are sent through the standard output.
+ * @param content {string} The content to be output to the user.
+ */
+declare const info: (content: Message) => void;
+/**
+ * Outputs a success message to the user.
+ * Success message receive a special formatting to make them stand out in the console.
+ * Note: Success messages are sent through the standard output.
+ * @param content {string} The content to be output to the user.
+ */
+declare const success: (content: Message) => void;
+/**
+ * Outputs a completed message to the user.
+ * Completed message receive a special formatting to make them stand out in the console.
+ * Note: Completed messages are sent through the standard output.
+ * @param content {string} The content to be output to the user.
+ */
+declare const completed: (content: Message) => void;
+/**
+ * Ouputs debug information to the user. By default these output is hidden unless the user calls the CLI with --verbose.
+ * Debug messages don't get additional formatting.
+ * Note: Debug messages are sent through the standard output.
+ * @param content {string} The content to be output to the user.
+ */
+declare const debug: (content: Message) => void;
+/**
+ * Outputs a warning message to the user.
+ * Warning messages receive a special formatting to make them stand out in the console.
+ * Note: Warning messages are sent through the standard output.
+ * @param content {string} The content to be output to the user.
+ */
+declare const warn: (content: Message) => void;
+/**
+ * Prints a new line in the terminal.
+ */
+declare const newline: () => void;
+/**
+ * Formats and outputs a fatal error.
+ * Note: This API is not intended to be used internally. If you want to
+ * abort the execution due to an error, raise a fatal error and let the
+ * error handler handle and format it.
+ * @param content {Fatal} The fatal error to be output.
+ */
+declare const error$1: (content: Fatal) => Promise<void>;
+declare function stringifyMessage(message: Message): string;
+interface OutputProcess {
+    /** The prefix to include in the logs
+     *   [vite] Output coming from Vite
+     */
+    prefix: string;
+    /**
+     * A callback to invoke the process. stdout and stderr should be used
+     * to send standard output and error data that gets formatted with the
+     * right prefix.
+     */
+    action: (stdout: Writable, stderr: Writable, signal: AbortSignal) => Promise<void>;
+}
+/**
+ * Use this function when you have multiple concurrent processes that send data events
+ * and we need to output them ensuring that they can visually differenciated by the user.
+ *
+ * @param processes {OutputProcess[]} A list of processes to run concurrently.
+ */
+declare function concurrent(processes: OutputProcess[], callback?: ((signal: AbortSignal) => void) | undefined): Promise<void>;
+declare function unstyled(message: string): string;
+declare function shouldDisplayColors(): boolean;
+
+declare const output_token: typeof token;
+type output_TokenizedString = TokenizedString;
+declare const output_TokenizedString: typeof TokenizedString;
+type output_Message = Message;
+declare const output_content: typeof content;
+type output_LogLevel = LogLevel;
+declare const output_currentLogLevel: typeof currentLogLevel;
+declare const output_shouldOutput: typeof shouldOutput;
+declare const output_info: typeof info;
+declare const output_success: typeof success;
+declare const output_completed: typeof completed;
+declare const output_debug: typeof debug;
+declare const output_warn: typeof warn;
+declare const output_newline: typeof newline;
+declare const output_stringifyMessage: typeof stringifyMessage;
+type output_OutputProcess = OutputProcess;
+declare const output_concurrent: typeof concurrent;
+declare const output_unstyled: typeof unstyled;
+declare const output_shouldDisplayColors: typeof shouldDisplayColors;
+declare namespace output {
+  export {
+    output_token as token,
+    output_TokenizedString as TokenizedString,
+    output_Message as Message,
+    output_content as content,
+    output_LogLevel as LogLevel,
+    output_currentLogLevel as currentLogLevel,
+    output_shouldOutput as shouldOutput,
+    output_info as info,
+    output_success as success,
+    output_completed as completed,
+    output_debug as debug,
+    output_warn as warn,
+    output_newline as newline,
+    error$1 as error,
+    output_stringifyMessage as stringifyMessage,
+    output_OutputProcess as OutputProcess,
+    output_concurrent as concurrent,
+    output_unstyled as unstyled,
+    output_shouldDisplayColors as shouldDisplayColors,
+  };
+}
+
 declare enum FatalErrorType {
     Abort = 0,
     AbortSilent = 1,
@@ -81,14 +354,14 @@ declare enum FatalErrorType {
 declare abstract class Fatal extends Error {
     tryMessage: string | null;
     type: FatalErrorType;
-    constructor(message: string, type: FatalErrorType, tryMessage?: string | null);
+    constructor(message: Message, type: FatalErrorType, tryMessage?: Message | null);
 }
 /**
  * An abort error is a fatal error that shouldn't be reported as a bug.
  * Those usually represent unexpected scenarios that we can't handle and that usually require some action from the developer
  */
 declare class Abort extends Fatal {
-    constructor(message: string, tryMessage?: string | null);
+    constructor(message: Message, tryMessage?: Message | null);
 }
 declare class AbortSilent extends Fatal {
     constructor();
@@ -97,7 +370,7 @@ declare class AbortSilent extends Fatal {
  * A bug error is an error that represents a bug and therefore should be reported.
  */
 declare class Bug extends Fatal {
-    constructor(message: string, tryMessage?: string | null);
+    constructor(message: Message, tryMessage?: string | null);
 }
 /**
  * A function that handles errors that blow up in the CLI.
@@ -109,30 +382,30 @@ declare function mapper(error: Error): Promise<Error>;
 declare function isFatal(error: Error): boolean;
 declare function shouldReport(error: Error): boolean;
 
-type error$1_Fatal = Fatal;
-declare const error$1_Fatal: typeof Fatal;
-type error$1_Abort = Abort;
-declare const error$1_Abort: typeof Abort;
-type error$1_AbortSilent = AbortSilent;
-declare const error$1_AbortSilent: typeof AbortSilent;
-type error$1_Bug = Bug;
-declare const error$1_Bug: typeof Bug;
-declare const error$1_handler: typeof handler;
-declare const error$1_mapper: typeof mapper;
-declare const error$1_isFatal: typeof isFatal;
-declare const error$1_shouldReport: typeof shouldReport;
-declare const error$1_AbortSignal: typeof AbortSignal;
-declare namespace error$1 {
+type error_Fatal = Fatal;
+declare const error_Fatal: typeof Fatal;
+type error_Abort = Abort;
+declare const error_Abort: typeof Abort;
+type error_AbortSilent = AbortSilent;
+declare const error_AbortSilent: typeof AbortSilent;
+type error_Bug = Bug;
+declare const error_Bug: typeof Bug;
+declare const error_handler: typeof handler;
+declare const error_mapper: typeof mapper;
+declare const error_isFatal: typeof isFatal;
+declare const error_shouldReport: typeof shouldReport;
+declare const error_AbortSignal: typeof AbortSignal;
+declare namespace error {
   export {
-    error$1_Fatal as Fatal,
-    error$1_Abort as Abort,
-    error$1_AbortSilent as AbortSilent,
-    error$1_Bug as Bug,
-    error$1_handler as handler,
-    error$1_mapper as mapper,
-    error$1_isFatal as isFatal,
-    error$1_shouldReport as shouldReport,
-    error$1_AbortSignal as AbortSignal,
+    error_Fatal as Fatal,
+    error_Abort as Abort,
+    error_AbortSilent as AbortSilent,
+    error_Bug as Bug,
+    error_handler as handler,
+    error_mapper as mapper,
+    error_isFatal as isFatal,
+    error_shouldReport as shouldReport,
+    error_AbortSignal as AbortSignal,
   };
 }
 
@@ -153,8 +426,8 @@ declare const open: (url: string) => Promise<void>;
  * @param args {string[]} Arguments to pass to the command.
  * @returns A promise that resolves with the aggregatted stdout of the command.
  */
-declare const captureOutput: (command: string, args: string[]) => Promise<string>;
-declare const exec: (command: string, args: string[], options?: ExecOptions) => Promise<execa.ExecaReturnValue<string>>;
+declare const captureOutput: (command: string, args: string[], options?: ExecOptions) => Promise<string>;
+declare const exec: (command: string, args: string[], options?: ExecOptions) => Promise<void>;
 interface ConcurrentExecCommand {
     prefix: string;
     executable: string;
@@ -282,6 +555,7 @@ declare function read$1(path: string): Promise<string>;
  * @param to {string} Destination path.
  */
 declare function copy(from: string, to: string): Promise<void>;
+declare function touch(path: string): Promise<void>;
 declare function write$1(path: string, data: string): Promise<void>;
 declare function append(path: string, data: string): Promise<void>;
 declare function mkdir(path: string): Promise<void>;
@@ -317,10 +591,17 @@ declare function hasExecutablePermissions(path: string): Promise<boolean>;
  * @returns {boolean} True if it exists.
  */
 declare function exists(path: string): Promise<boolean>;
+/**
+ * Format a string using prettier. Return the formatted content.
+ */
+declare function format(content: string, options: {
+    path: string;
+}): Promise<string>;
 
 declare const file_stripUp: typeof stripUp;
 declare const file_inTemporaryDirectory: typeof inTemporaryDirectory;
 declare const file_copy: typeof copy;
+declare const file_touch: typeof touch;
 declare const file_append: typeof append;
 declare const file_mkdir: typeof mkdir;
 declare const file_remove: typeof remove;
@@ -331,12 +612,14 @@ declare const file_move: typeof move;
 declare const file_chmod: typeof chmod;
 declare const file_hasExecutablePermissions: typeof hasExecutablePermissions;
 declare const file_exists: typeof exists;
+declare const file_format: typeof format;
 declare namespace file {
   export {
     file_stripUp as stripUp,
     file_inTemporaryDirectory as inTemporaryDirectory,
     read$1 as read,
     file_copy as copy,
+    file_touch as touch,
     write$1 as write,
     file_append as append,
     file_mkdir as mkdir,
@@ -348,20 +631,24 @@ declare namespace file {
     file_chmod as chmod,
     file_hasExecutablePermissions as hasExecutablePermissions,
     file_exists as exists,
+    file_format as format,
   };
 }
 
 declare const factory: simple_git.SimpleGitFactory;
+declare function initializeRepository(directory: string): Promise<void>;
 declare function downloadRepository({ repoUrl, destination }: {
     repoUrl: string;
     destination: string;
 }): Promise<void>;
 
 declare const git_factory: typeof factory;
+declare const git_initializeRepository: typeof initializeRepository;
 declare const git_downloadRepository: typeof downloadRepository;
 declare namespace git {
   export {
     git_factory as factory,
+    git_initializeRepository as initializeRepository,
     git_downloadRepository as downloadRepository,
   };
 }
@@ -403,274 +690,12 @@ declare namespace github {
   };
 }
 
-declare const dependencyManager: readonly ["yarn", "npm", "pnpm"];
-declare type DependencyManager = typeof dependencyManager[number];
-declare const PackageJsonNotFoundError: (directory: string) => Abort;
-/**
- * Returns the dependency manager used to run the create workflow.
- * @param env {Object} The environment variables of the process in which the CLI runs.
- * @returns The dependency manager
- */
-declare function dependencyManagerUsedForCreating(env?: NodeJS.ProcessEnv): DependencyManager;
-interface InstallNPMDependenciesRecursivelyOptions {
-    /**
-     * The dependency manager to use to install the dependencies.
-     */
-    dependencyManager: DependencyManager;
-    /**
-     * The directory from where we'll find package.json's recursively
-     */
-    directory: string;
-    /**
-     * Specifies the maximum depth of the glob search.
-     */
-    deep?: number;
-}
-/**
- * This function traverses down a directory tree to find directories containing a package.json
- * and installs the dependencies if needed. To know if it's needed, it uses the "check" command
- * provided by dependency managers.
- * @param options {InstallNPMDependenciesRecursivelyOptions} Options to install dependencies recursively.
- */
-declare function installNPMDependenciesRecursively(options: InstallNPMDependenciesRecursivelyOptions): Promise<void>;
-/**
- * Installs the dependencies in the given directory.
- * @param directory {string} The directory that contains the package.json
- * @param dependencyManager {DependencyManager} The dependency manager to use to install the dependencies.
- * @param stdout {Writable} Standard output stream.
- * @param stderr {Writable} Standard error stream.
- * @param signal {AbortSignal} Abort signal.
- * @returns stderr {Writable} Standard error stream.
- */
-declare function install(directory: string, dependencyManager: DependencyManager, stdout?: Writable, stderr?: Writable, signal?: AbortSignal): Promise<void>;
-/**
- * Returns the name of the package configured in its package.json
- * @param packageJsonPath {string} Path to the package.json file
- * @returns A promise that resolves with the name.
- */
-declare function getPackageName(packageJsonPath: string): Promise<string>;
-/**
- * Returns the list of production and dev dependencies of a package.json
- * @param packageJsonPath {string} Path to the package.json file
- * @returns A promise that resolves with the list of dependencies.
- */
-declare function getDependencies(packageJsonPath: string): Promise<{
-    [key: string]: string;
-}>;
-declare type DependencyType = 'dev' | 'prod' | 'peer';
-interface AddNPMDependenciesIfNeededOptions {
-    /** How dependencies should be added */
-    type: DependencyType;
-    /** The dependency manager to use to add dependencies */
-    dependencyManager: DependencyManager;
-    /** The directory that contains the package.json where dependencies will be added */
-    directory: string;
-    /** Standard output coming from the underlying installation process */
-    stdout?: Writable;
-    /** Standard error coming from the underlying installation process */
-    stderr?: Writable;
-    /** Abort signal to stop the process */
-    signal?: AbortSignal;
-}
-/**
- * Adds dependencies to a Node project (i.e. a project that has a package.json)
- * @param dependencies {string[]} List of dependencies to be added.
- * @param options {AddNPMDependenciesIfNeededOptions} Options for adding dependencies.
- */
-declare function addNPMDependenciesIfNeeded(dependencies: string[], options: AddNPMDependenciesIfNeededOptions): Promise<void>;
-
-declare const dependency_dependencyManager: typeof dependencyManager;
-type dependency_DependencyManager = DependencyManager;
-declare const dependency_PackageJsonNotFoundError: typeof PackageJsonNotFoundError;
-declare const dependency_dependencyManagerUsedForCreating: typeof dependencyManagerUsedForCreating;
-declare const dependency_installNPMDependenciesRecursively: typeof installNPMDependenciesRecursively;
-declare const dependency_install: typeof install;
-declare const dependency_getPackageName: typeof getPackageName;
-declare const dependency_getDependencies: typeof getDependencies;
-declare const dependency_addNPMDependenciesIfNeeded: typeof addNPMDependenciesIfNeeded;
-declare namespace dependency {
-  export {
-    dependency_dependencyManager as dependencyManager,
-    dependency_DependencyManager as DependencyManager,
-    dependency_PackageJsonNotFoundError as PackageJsonNotFoundError,
-    dependency_dependencyManagerUsedForCreating as dependencyManagerUsedForCreating,
-    dependency_installNPMDependenciesRecursively as installNPMDependenciesRecursively,
-    dependency_install as install,
-    dependency_getPackageName as getPackageName,
-    dependency_getDependencies as getDependencies,
-    dependency_addNPMDependenciesIfNeeded as addNPMDependenciesIfNeeded,
-  };
-}
-
-declare enum ContentTokenType {
-    Command = 0,
-    Path = 1,
-    Link = 2,
-    Heading = 3,
-    SubHeading = 4,
-    Italic = 5,
-    ErrorText = 6,
-    Yellow = 7,
-    Cyan = 8,
-    Magenta = 9,
-    Green = 10
-}
-interface ContentMetadata {
-    link?: string;
-}
-declare class ContentToken {
-    type: ContentTokenType;
-    value: string;
-    metadata: ContentMetadata;
-    constructor(value: string, metadata: ContentMetadata | undefined, type: ContentTokenType);
-}
-declare const token: {
-    genericShellCommand: (value: string) => ContentToken;
-    path: (value: string) => ContentToken;
-    link: (value: string, link: string) => ContentToken;
-    heading: (value: string) => ContentToken;
-    subheading: (value: string) => ContentToken;
-    italic: (value: string) => ContentToken;
-    errorText: (value: string) => ContentToken;
-    cyan: (value: string) => ContentToken;
-    yellow: (value: string) => ContentToken;
-    magenta: (value: string) => ContentToken;
-    green: (value: string) => ContentToken;
-    command: (dependencyManager: DependencyManager, scriptName: string, ...scriptArgs: string[]) => ContentToken;
-};
-declare class TokenizedString {
-    value: string;
-    constructor(value: string);
-}
-declare type Message = string | TokenizedString;
-declare function content(strings: TemplateStringsArray, ...keys: (ContentToken | string)[]): TokenizedString;
-/** Log levels */
-declare type LogLevel = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'silent';
-/**
- *
- * @returns {LogLevel} It returns the log level set by the user.
- */
-declare const currentLogLevel: () => LogLevel;
-declare const shouldOutput: (logLevel: LogLevel) => boolean;
-/**
- * Ouputs information to the user. This is akin to "console.log"
- * Info messages don't get additional formatting.
- * Note: Info messages are sent through the standard output.
- * @param content {string} The content to be output to the user.
- */
-declare const info: (content: Message) => void;
-/**
- * Outputs a success message to the user.
- * Success message receive a special formatting to make them stand out in the console.
- * Note: Success messages are sent through the standard output.
- * @param content {string} The content to be output to the user.
- */
-declare const success: (content: Message) => void;
-/**
- * Outputs a completed message to the user.
- * Completed message receive a special formatting to make them stand out in the console.
- * Note: Completed messages are sent through the standard output.
- * @param content {string} The content to be output to the user.
- */
-declare const completed: (content: Message) => void;
-/**
- * Ouputs debug information to the user. By default these output is hidden unless the user calls the CLI with --verbose.
- * Debug messages don't get additional formatting.
- * Note: Debug messages are sent through the standard output.
- * @param content {string} The content to be output to the user.
- */
-declare const debug: (content: Message) => void;
-/**
- * Outputs a warning message to the user.
- * Warning messages receive a special formatting to make them stand out in the console.
- * Note: Warning messages are sent through the standard output.
- * @param content {string} The content to be output to the user.
- */
-declare const warn: (content: Message) => void;
-/**
- * Prints a new line in the terminal.
- */
-declare const newline: () => void;
-/**
- * Turns the given object into a colorized JSON.
- * @param json {any} Object to turn into a JSON and colorize
- * @returns {string} Colorized JSON representation of the given object.
- */
-declare const colorJson: (json: any) => string;
-/**
- * Formats and outputs a fatal error.
- * Note: This API is not intended to be used internally. If you want to
- * abort the execution due to an error, raise a fatal error and let the
- * error handler handle and format it.
- * @param content {Fatal} The fatal error to be output.
- */
-declare const error: (content: Fatal) => Promise<void>;
-declare function stringifyMessage(message: Message): string;
-interface OutputProcess {
-    /** The prefix to include in the logs
-     *   [vite] Output coming from Vite
-     */
-    prefix: string;
-    /**
-     * A callback to invoke the process. stdout and stderr should be used
-     * to send standard output and error data that gets formatted with the
-     * right prefix.
-     */
-    action: (stdout: Writable, stderr: Writable, signal: AbortSignal) => Promise<void>;
-}
-/**
- * Use this function when you have multiple concurrent processes that send data events
- * and we need to output them ensuring that they can visually differenciated by the user.
- *
- * @param processes {OutputProcess[]} A list of processes to run concurrently.
- */
-declare function concurrent(processes: OutputProcess[]): Promise<void>;
-declare function unstyled(message: string): string;
-declare function shouldDisplayColors(): boolean;
+declare function generate(suffix: string): string;
 
-declare const output_token: typeof token;
-type output_TokenizedString = TokenizedString;
-declare const output_TokenizedString: typeof TokenizedString;
-type output_Message = Message;
-declare const output_content: typeof content;
-type output_LogLevel = LogLevel;
-declare const output_currentLogLevel: typeof currentLogLevel;
-declare const output_shouldOutput: typeof shouldOutput;
-declare const output_info: typeof info;
-declare const output_success: typeof success;
-declare const output_completed: typeof completed;
-declare const output_debug: typeof debug;
-declare const output_warn: typeof warn;
-declare const output_newline: typeof newline;
-declare const output_colorJson: typeof colorJson;
-declare const output_error: typeof error;
-declare const output_stringifyMessage: typeof stringifyMessage;
-type output_OutputProcess = OutputProcess;
-declare const output_concurrent: typeof concurrent;
-declare const output_unstyled: typeof unstyled;
-declare const output_shouldDisplayColors: typeof shouldDisplayColors;
-declare namespace output {
+declare const haiku_generate: typeof generate;
+declare namespace haiku {
   export {
-    output_token as token,
-    output_TokenizedString as TokenizedString,
-    output_Message as Message,
-    output_content as content,
-    output_LogLevel as LogLevel,
-    output_currentLogLevel as currentLogLevel,
-    output_shouldOutput as shouldOutput,
-    output_info as info,
-    output_success as success,
-    output_completed as completed,
-    output_debug as debug,
-    output_warn as warn,
-    output_newline as newline,
-    output_colorJson as colorJson,
-    output_error as error,
-    output_stringifyMessage as stringifyMessage,
-    output_OutputProcess as OutputProcess,
-    output_concurrent as concurrent,
-    output_unstyled as unstyled,
-    output_shouldDisplayColors as shouldDisplayColors,
+    haiku_generate as generate,
   };
 }
 
@@ -681,10 +706,10 @@ declare namespace output {
  */
 declare function latestNpmPackageVersion(name: string): Promise<string>;
 
-declare const version_latestNpmPackageVersion: typeof latestNpmPackageVersion;
-declare namespace version {
+declare const version$1_latestNpmPackageVersion: typeof latestNpmPackageVersion;
+declare namespace version$1 {
   export {
-    version_latestNpmPackageVersion as latestNpmPackageVersion,
+    version$1_latestNpmPackageVersion as latestNpmPackageVersion,
   };
 }
 
@@ -718,6 +743,12 @@ declare function homeDirectory(): string;
  * @returns true if SHOPIFY_CONFIG is debug
  */
 declare function isDebug(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Returns true if the CLI is running in verbose mode.
+ * @param env The environment variables from the environment of the current process.
+ * @returns true if SHOPIFY_FLAG_VERBOSE is truthy or the flag --verbose has been passed
+ */
+declare function isVerbose(env?: NodeJS.ProcessEnv): boolean;
 /**
  * Returns true if the environment in which the CLI is running is either
  * a local environment (where dev is present) or a cloud environment (spin).
@@ -732,17 +763,27 @@ declare function isShopify(env?: NodeJS.ProcessEnv): Promise<boolean>;
  * @returns True if the SHOPIFY_UNIT_TEST environment variable is truthy.
  */
 declare function isUnitTest(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Returns true if reporting analytics is enabled.
+ * @param env The environment variables from the environment of the current process.
+ * @returns true unless SHOPIFY_CLI_NO_ANALYTICS is truthy.
+ */
+declare function analyticsDisabled(env?: NodeJS.ProcessEnv): boolean;
 
 declare const local_homeDirectory: typeof homeDirectory;
 declare const local_isDebug: typeof isDebug;
+declare const local_isVerbose: typeof isVerbose;
 declare const local_isShopify: typeof isShopify;
 declare const local_isUnitTest: typeof isUnitTest;
+declare const local_analyticsDisabled: typeof analyticsDisabled;
 declare namespace local {
   export {
     local_homeDirectory as homeDirectory,
     local_isDebug as isDebug,
+    local_isVerbose as isVerbose,
     local_isShopify as isShopify,
     local_isUnitTest as isUnitTest,
+    local_analyticsDisabled as analyticsDisabled,
   };
 }
 
@@ -1189,15 +1230,16 @@ interface GenerateSignedUploadUrlSchema {
 }
 
 declare const CreateDeployment: string;
+interface ExtensionSettings {
+    uuid: string;
+    config: string;
+    context: string;
+}
 interface CreateDeploymentVariables {
     apiKey: string;
     uuid: string;
     bundleUrl: string;
-    extensions: {
-        uuid: string;
-        config: string;
-        context: string;
-    }[];
+    extensions: ExtensionSettings[];
 }
 interface CreateDeploymentSchema {
     deploymentCreate: {
@@ -1418,6 +1460,7 @@ declare const index_GenerateSignedUploadUrl: typeof GenerateSignedUploadUrl;
 type index_GenerateSignedUploadUrlVariables = GenerateSignedUploadUrlVariables;
 type index_GenerateSignedUploadUrlSchema = GenerateSignedUploadUrlSchema;
 declare const index_CreateDeployment: typeof CreateDeployment;
+type index_ExtensionSettings = ExtensionSettings;
 type index_CreateDeploymentVariables = CreateDeploymentVariables;
 type index_CreateDeploymentSchema = CreateDeploymentSchema;
 declare const index_AllStoresByOrganizationQuery: typeof AllStoresByOrganizationQuery;
@@ -1466,6 +1509,7 @@ declare namespace index {
     index_GenerateSignedUploadUrlVariables as GenerateSignedUploadUrlVariables,
     index_GenerateSignedUploadUrlSchema as GenerateSignedUploadUrlSchema,
     index_CreateDeployment as CreateDeployment,
+    index_ExtensionSettings as ExtensionSettings,
     index_CreateDeploymentVariables as CreateDeploymentVariables,
     index_CreateDeploymentSchema as CreateDeploymentSchema,
     index_AllStoresByOrganizationQuery as AllStoresByOrganizationQuery,
@@ -1579,13 +1623,16 @@ interface ExecThemeCheckCLIOptions {
     stderr: Writable;
 }
 declare function execThemeCheckCLI({ directories, args, stdout, stderr, }: ExecThemeCheckCLIOptions): Promise<void[]>;
+declare function version(): Promise<string | undefined>;
 
 declare const ruby_execCLI: typeof execCLI;
 declare const ruby_execThemeCheckCLI: typeof execThemeCheckCLI;
+declare const ruby_version: typeof version;
 declare namespace ruby {
   export {
     ruby_execCLI as execCLI,
     ruby_execThemeCheckCLI as execThemeCheckCLI,
+    ruby_version as version,
   };
 }
 
@@ -1757,6 +1804,8 @@ declare const constants: {
         spinNamespace: string;
         spinHost: string;
         partnersToken: string;
+        verbose: string;
+        noAnalytics: string;
     };
     paths: {
         executables: {
@@ -1801,5 +1850,23 @@ declare namespace plugins {
   };
 }
 
-export { abort, api, archiver, checksum, cli, constants, dependency, dotEnv as dotenv, environment, error$1 as error, file, git, github, http, id, npm, os, output, path, plugins, port, ruby, schema, semver, session, store, string, system, template, temporary, toml, ui, version, yaml };
+/**
+ * Check if user editor is VS Code
+ */
+declare const isVSCode: (root?: string) => Promise<boolean>;
+/**
+ * Add VSCode extension recommendations
+ */
+declare function addRecommendedExtensions(directory: string, recommendations: string[]): Promise<void>;
+
+declare const vscode_isVSCode: typeof isVSCode;
+declare const vscode_addRecommendedExtensions: typeof addRecommendedExtensions;
+declare namespace vscode {
+  export {
+    vscode_isVSCode as isVSCode,
+    vscode_addRecommendedExtensions as addRecommendedExtensions,
+  };
+}
+
+export { abort, api, archiver, checksum, cli, constants, dependency, dotEnv as dotenv, environment, error, file, git, github, haiku, http, id, npm, os, output, path, plugins, port, ruby, schema, semver, session, store, string, system, template, temporary, toml, ui, version$1 as version, vscode, yaml };
 //# sourceMappingURL=index.d.ts.map