@flarum/cli 2.0.2 → 3.0.1

package/lib/base-command.d.ts

@@ -8,17 +8,29 @@ export declare enum LocationType {
     FLARUM_MONOREPO = 2
 }
 export default abstract class BaseCommand extends Command {
-    protected STUB_PATH: string;
+    STUB_PATH: string;
     protected dry: boolean;
     protected locationType?: LocationType;
     protected args: Record<string, any>;
     protected flags: any;
     static flags: Interfaces.FlagInput<any>;
-    static args: {
-        name: string;
-        description: string;
-    }[];
+    static args: Interfaces.ArgInput;
+    static classNameArg: Interfaces.Arg;
     protected requireExistingExtension: boolean;
+    protected skipFinalMessage: boolean;
+    runSteps(steps: StepManager<FlarumProviders>): Promise<{
+        succeeded: true;
+        messages: import("boilersmith/io").Message[];
+        stepsRan: string[];
+    } | {
+        succeeded: false;
+        error: string;
+        errorTrace?: string | undefined;
+        messages: import("boilersmith/io").Message[];
+        stepsRan: string[];
+        e?: any;
+    }>;
+    extRoot(path: string | undefined): Promise<string>;
     run(): Promise<void>;
     protected welcomeMessage(): string;
     protected goodbyeMessage(): string;
@@ -38,8 +50,10 @@ export default abstract class BaseCommand extends Command {
         path: string;
         type: LocationType;
     }>;
+    protected confirmed: boolean;
     protected confirmExtDir(extRoot: string): Promise<void>;
     protected ensureComposerInstallRan(extRoot: string): Promise<void>;
+    continueWhenReady(io: IO): Promise<void>;
     /**
      * If false, files do not exist so no need to override.
      * If true, files should be overriden.

package/lib/base-command.js

@@ -3,16 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocationType = void 0;
 const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
-const cli_ux_1 = (0, tslib_1.__importDefault)(require("cli-ux"));
+const cli_ux_1 = tslib_1.__importDefault(require("cli-ux"));
 const path_1 = require("path");
-const globby_1 = (0, tslib_1.__importDefault)(require("globby"));
+const globby_1 = tslib_1.__importDefault(require("globby"));
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const io_1 = require("boilersmith/io");
 const step_manager_1 = require("boilersmith/step-manager");
 const paths_1 = require("boilersmith/paths");
 const php_provider_1 = require("./providers/php-provider");
-const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const errors_1 = require("@oclif/errors");
 const monorepo_1 = require("./utils/monorepo");
 const mem_fs_1 = require("mem-fs");
@@ -28,16 +28,21 @@ class BaseCommand extends core_1.Command {
         this.STUB_PATH = (0, path_1.resolve)(__dirname, '../boilerplate/stubs/');
         this.dry = false;
         this.requireExistingExtension = true;
+        this.skipFinalMessage = false;
+        this.confirmed = false;
     }
-    async run() {
-        const { args, flags } = await this.parse(this.constructor);
+    async runSteps(steps) {
+        const { args } = await this.parse(this.constructor);
         this.args = args;
-        this.flags = flags;
         const path = args.path;
-        const welcomeMessage = this.welcomeMessage();
-        if (welcomeMessage) {
-            this.log(welcomeMessage);
-        }
+        const paths = new paths_1.NodePaths({
+            requestedDir: path,
+            package: await this.extRoot(path),
+        });
+        const phpProvider = new php_provider_1.PhpSubsystemProvider((0, path_1.resolve)(__dirname, '../php-subsystem/index.php'));
+        return steps.run(paths, this.genIO(), { php: phpProvider }, this.dry, args);
+    }
+    async extRoot(path) {
         let extRoot;
         if (this.requireExistingExtension) {
             const rootData = await this.getFlarumExtensionRoot(path || process.cwd());
@@ -48,35 +53,52 @@ class BaseCommand extends core_1.Command {
         else {
             extRoot = path || process.cwd();
         }
+        return extRoot;
+    }
+    async run() {
+        var _a;
+        const { args, flags } = await this.parse(this.constructor);
+        this.args = args;
+        this.flags = flags;
+        const path = args.path;
+        const welcomeMessage = this.welcomeMessage();
+        if (welcomeMessage) {
+            this.log(welcomeMessage);
+            await this.continueWhenReady(this.genIO());
+        }
+        const extRoot = await this.extRoot(path);
         await this.additionalPreRunChecks(extRoot);
-        const paths = new paths_1.NodePaths({
-            requestedDir: path,
-            package: extRoot,
-        });
-        const phpProvider = new php_provider_1.PhpSubsystemProvider((0, path_1.resolve)(__dirname, '../php-subsystem/index.php'));
-        const out = await this.steps(new step_manager_1.StepManager(), extRoot).run(paths, this.genIO(), { php: phpProvider }, this.dry);
+        const out = await this.runSteps(this.steps(new step_manager_1.StepManager(), extRoot));
         const errorMessages = out.messages.filter((m) => m.type === 'error');
-        this.log('\n\n');
-        if (out.succeeded && errorMessages.length === 0) {
+        // this.log('\n\n');
+        if (!this.skipFinalMessage && out.succeeded && errorMessages.length === 0) {
             this.log(chalk_1.default.bold(chalk_1.default.underline(chalk_1.default.green('Success! The following steps were completed:'))));
         }
-        else if (out.succeeded) {
+        else if (!this.skipFinalMessage && out.succeeded) {
             this.log(chalk_1.default.bold(chalk_1.default.underline(chalk_1.default.yellow('All steps completed, but with some errors:'))));
             for (const message of errorMessages) {
                 this.log(chalk_1.default.dim(chalk_1.default.red(message.message)));
             }
             this.log(chalk_1.default.bold(chalk_1.default.yellow('The steps that completed were:')));
         }
-        else if (out.error.startsWith('EEXIT:')) {
+        else if (!out.succeeded && out.error.startsWith('EEXIT:')) {
             this.log(chalk_1.default.bold(chalk_1.default.underline(chalk_1.default.red('Exiting.'))));
-            if (out.stepsRan.length > 0) {
+            if (!this.skipFinalMessage && out.stepsRan.length > 0) {
                 this.log(chalk_1.default.bold(chalk_1.default.yellow('Before the exit, the following steps were completed:')));
             }
         }
-        else {
-            this.log(chalk_1.default.bold(chalk_1.default.underline(chalk_1.default.red('Error occurred, and could not complete:'))));
-            this.log(chalk_1.default.red(out.error));
-            if (out.errorTrace) {
+        else if (!out.succeeded) {
+            const prettyPrint = ((_a = out.e) === null || _a === void 0 ? void 0 : _a.code) === 'FL_ERR';
+            if (!prettyPrint)
+                this.log(chalk_1.default.bold(chalk_1.default.underline(chalk_1.default.red('Error occurred, and could not complete:'))));
+            if (prettyPrint) {
+                this.log('\n');
+                this.log('\u001B[A     => ' + chalk_1.default.bgRed.bold('   ERROR   ') + ' ' + chalk_1.default.red(out.error));
+            }
+            else {
+                this.log(chalk_1.default.red(out.error));
+            }
+            if (out.errorTrace && !prettyPrint) {
                 this.log(chalk_1.default.dim(chalk_1.default.red(out.errorTrace)));
             }
             if (out.stepsRan.length > 0) {
@@ -84,8 +106,10 @@ class BaseCommand extends core_1.Command {
                 this.log(chalk_1.default.bold(chalk_1.default.yellow('Before the error, the following steps were completed:')));
             }
         }
-        for (const stepName of out.stepsRan)
-            this.log(`- ${chalk_1.default.dim(stepName)}`);
+        if (!this.skipFinalMessage) {
+            for (const stepName of out.stepsRan)
+                this.log(`- ${chalk_1.default.dim(stepName)}`);
+        }
         this.log('');
         const nonErrorMessages = out.messages.filter((m) => m.type !== 'error');
         if (nonErrorMessages.length > 0) {
@@ -116,7 +140,7 @@ class BaseCommand extends core_1.Command {
     // Confirmation
     // ----------------------------------------------------------------
     genIO() {
-        return new io_1.PromptsIO({}, [], this.flags['no-interaction'], errors_1.exit);
+        return new io_1.PromptsIO(this.args, [], this.flags['no-interaction'], errors_1.exit);
     }
     monorepoPaths(options) {
         var _a, _b;
@@ -171,6 +195,8 @@ class BaseCommand extends core_1.Command {
 - Flarum monorepos must have a valid 'flarum-monorepo.json' file`);
     }
     async confirmExtDir(extRoot) {
+        if (this.confirmed)
+            return;
         const verify = await this.genIO().getParam({
             name: 'verify',
             type: 'confirm',
@@ -179,6 +205,7 @@ class BaseCommand extends core_1.Command {
         });
         if (!verify)
             this.exit();
+        this.confirmed = true;
     }
     async ensureComposerInstallRan(extRoot) {
         if ((0, fs_1.existsSync)((0, path_1.resolve)(extRoot, 'vendor/flarum/core/composer.json')))
@@ -199,6 +226,19 @@ class BaseCommand extends core_1.Command {
             this.error("Run `composer install` in your extension's root directory, then try again.");
         }
     }
+    async continueWhenReady(io) {
+        const continueUpgrade = await io.getParam({
+            name: 'continue',
+            type: 'confirm',
+            message: 'Ready to continue?',
+            initial: true,
+        });
+        if (!continueUpgrade) {
+            this.log('');
+            this.log('Aborted.');
+            this.exit();
+        }
+    }
     /**
      * If false, files do not exist so no need to override.
      * If true, files should be overriden.
@@ -240,3 +280,8 @@ BaseCommand.args = [
         description: 'Where should this command be executed?',
     },
 ];
+BaseCommand.classNameArg = {
+    name: 'className',
+    description: 'The name of the class to generate',
+    required: false,
+};

package/lib/boilersmith/io.d.ts

@@ -1,13 +1,13 @@
 import { PromptObject, PromptType } from 'prompts';
-declare type BooleanPromptType = PromptType & ('confirm' | 'toggle');
-declare type StringPromptType = PromptType & ('text' | 'password' | 'invisible' | 'autocomplete');
-declare type DatePromptType = PromptType & 'date';
-declare type ListPromptType = PromptType & 'list';
-export declare type ParamDef<N extends string = string> = Omit<PromptObject<N>, 'name'> & {
+type BooleanPromptType = PromptType & ('confirm' | 'toggle');
+type StringPromptType = PromptType & ('text' | 'password' | 'invisible' | 'autocomplete');
+type DatePromptType = PromptType & 'date';
+type ListPromptType = PromptType & 'list';
+export type ParamDef<N extends string = string> = Omit<PromptObject<N>, 'name'> & {
     name: N;
     message: string;
 };
-export declare type Message = {
+export type Message = {
     type: 'info' | 'warning' | 'error';
     message: string;
 };
@@ -45,8 +45,9 @@ export interface IO {
      */
     getOutput(): Message[];
     newInstance(cache: Record<string, unknown>, messages: Message[]): IO;
+    pushCache(params: Record<string, unknown>): void;
 }
-declare type OnCancel = () => void;
+type OnCancel = () => void;
 export declare class PromptsIO implements IO {
     supportsAnsiColor: boolean;
     protected cache: Map<string, unknown>;
@@ -64,6 +65,7 @@ export declare class PromptsIO implements IO {
      * @internal
      */
     cached(): Record<string, unknown>;
+    pushCache(params: Record<string, unknown>): void;
     info(message: string, immediate: boolean): void;
     warning(message: string, immediate: boolean): void;
     error(message: string, immediate: false): void;

package/lib/boilersmith/io.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptsIO = void 0;
 const tslib_1 = require("tslib");
-const prompts_1 = (0, tslib_1.__importDefault)(require("prompts"));
-const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const prompts_1 = tslib_1.__importDefault(require("prompts"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
 class PromptsIO {
     constructor(initial = {}, messages = [], noInteraction = false, onCancel = () => {
         throw new Error('EEXIT: 0');
@@ -21,20 +21,28 @@ class PromptsIO {
         if (this.cache.has(paramName)) {
             return this.cache.get(paramName);
         }
+        let initial = null;
+        if (paramDef.initial && paramDef.initial instanceof Function) {
+            initial = paramDef.initial((_a = this.prev) === null || _a === void 0 ? void 0 : _a.val, this.cache, (_b = this.prev) === null || _b === void 0 ? void 0 : _b.prompt);
+        }
+        else if (paramDef.type === 'confirm' || paramDef.type === 'toggle') {
+            initial = ((_c = paramDef.initial) !== null && _c !== void 0 ? _c : false);
+        }
+        else if ('initial' in paramDef) {
+            initial = paramDef.initial;
+        }
+        else if ('choices' in paramDef) {
+            initial = paramDef.choices.filter((c) => c.selected).map((c) => c.value);
+        }
+        else if (this.noInteraction) {
+            return this.error(`No-Interaction mode is on, but input is required for param "${paramName}".`, true);
+        }
+        if (initial) {
+            paramDef.initial = initial;
+        }
         let resValue;
-        if (this.noInteraction) {
-            if (paramDef.initial && paramDef.initial instanceof Function) {
-                resValue = paramDef.initial((_a = this.prev) === null || _a === void 0 ? void 0 : _a.val, this.cache, (_b = this.prev) === null || _b === void 0 ? void 0 : _b.prompt);
-            }
-            else if (paramDef.type === 'confirm' || paramDef.type === 'toggle') {
-                resValue = ((_c = paramDef.initial) !== null && _c !== void 0 ? _c : false);
-            }
-            else if ('initial' in paramDef) {
-                resValue = paramDef.initial;
-            }
-            else {
-                return this.error(`No-Interaction mode is on, but input is required for param "${paramName}".`, true);
-            }
+        if (initial !== null && this.noInteraction) {
+            resValue = initial;
         }
         else {
             const res = (await (0, prompts_1.default)(paramDef, {
@@ -63,6 +71,11 @@ class PromptsIO {
             return obj;
         }, {});
     }
+    pushCache(params) {
+        for (const [key, value] of Object.entries(params)) {
+            this.cache.set(key, value);
+        }
+    }
     info(message, immediate) {
         if (immediate) {
             console.log(message);

package/lib/boilersmith/paths.d.ts

@@ -5,7 +5,7 @@ export interface Paths {
     monorepo(...path: string[]): string | null;
     onMonorepoSub(packagePath: string, monorepoPath?: string): Paths;
 }
-declare type InternalPaths = {
+type InternalPaths = {
     package: string;
     monorepo?: string | null;
     requestedDir?: string | null;

package/lib/boilersmith/scaffolding/audit-step-factory.js

@@ -7,7 +7,7 @@ const rename_keys_1 = require("../utils/rename-keys");
 const module_1 = require("./module");
 const template_param_1 = require("./template-param");
 const cond_format_1 = require("boilersmith/utils/cond-format");
-const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const fs_1 = require("fs");
 function auditStepFactory(dry, scaffoldDir, modules, templateParams, excludeScaffoldingFunc, moduleStatusCache) {
     let modulesEnabled;

package/lib/boilersmith/scaffolding/module.d.ts

@@ -2,7 +2,7 @@ import { Store } from 'mem-fs';
 import { IO } from 'boilersmith/io';
 import { Paths } from 'boilersmith/paths';
 import { ExcludeScaffoldingFunc } from './scaffolder';
-declare type FileOwnershipCommon<N extends string> = {
+type FileOwnershipCommon<N extends string> = {
     /**
      * The path to the file
      */
@@ -23,7 +23,7 @@ declare type FileOwnershipCommon<N extends string> = {
      */
     doNotUpdate?: boolean;
 };
-declare type FileOwnership<N extends string> = (FileOwnershipCommon<N> & {
+type FileOwnership<N extends string> = (FileOwnershipCommon<N> & {
     /**
      * If in a monorepo, should the file be placed relative to the monorepo root, and if so, where?
      * If provided, takes priority over destPath.
@@ -81,8 +81,8 @@ interface TogglableModule<N extends string> extends CommonModule<N> {
      */
     inferEnabled?: (fs: Store, paths: Paths) => Promise<boolean | undefined>;
 }
-export declare type Module<N extends string = string> = UntoggleableModule<N> | TogglableModule<N>;
-export declare type ModuleStatusCache<N extends string> = {
+export type Module<N extends string = string> = UntoggleableModule<N> | TogglableModule<N>;
+export type ModuleStatusCache<N extends string> = {
     get: (module: Module<N>, fs: Store, paths: Paths) => Promise<boolean | undefined>;
     set: (module: Module<N>, val: boolean, fs: Store, paths: Paths) => Promise<void>;
 };

package/lib/boilersmith/scaffolding/module.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyModule = exports.setModuleValue = exports.currModulesEnabled = exports.promptModulesEnabled = void 0;
 const tslib_1 = require("tslib");
-const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const mem_fs_editor_1 = require("mem-fs-editor");
 const path_1 = require("path");
-const pick_deep_1 = (0, tslib_1.__importDefault)(require("pick-deep"));
+const pick_deep_1 = tslib_1.__importDefault(require("pick-deep"));
 const read_tpl_1 = require("boilersmith/utils/read-tpl");
 const clone_and_fill_1 = require("boilersmith/utils/clone-and-fill");
 const rename_keys_1 = require("boilersmith/utils/rename-keys");
@@ -64,7 +64,6 @@ async function setModuleValue(module, enabled, fs, paths, cache) {
     }
 }
 exports.setModuleValue = setModuleValue;
-// eslint-disable-next-line max-params,complexity
 async function applyModule(module, modulesEnabled, paramVals, scaffoldDir, fs, paths, 
 // eslint-disable-next-line unicorn/no-object-as-default-parameter
 excludeScaffolding = { files: [], configKeys: {} }, isInitial = false) {
@@ -92,8 +91,6 @@ excludeScaffolding = { files: [], configKeys: {} }, isInitial = false) {
         modules: modulesEnabled,
     };
     const tplDataFlat = Object.assign(Object.assign({}, (0, rename_keys_1.renameKeys)(tplData.modules, (k) => `modules.${k}`)), (0, rename_keys_1.renameKeys)(tplData.params, (k) => `params.${k}`));
-    // This is necessary because one layer of escaped backslashes is lost on template population.
-    tplData.params = Object.fromEntries(Object.entries(paramVals).map(([k, v]) => [k, typeof v === 'string' ? v.replace('\\', '\\\\') : v]));
     for (const file of module.filesToReplace) {
         const path = typeof file === 'string' ? file : file.path;
         const moduleDeps = typeof file === 'string' ? [] : (_a = file.moduleDeps) !== null && _a !== void 0 ? _a : [];
@@ -122,8 +119,11 @@ excludeScaffolding = { files: [], configKeys: {} }, isInitial = false) {
         fsEditor.write(copyTo, source);
     }
     const jsonPaths = (0, clone_and_fill_1.cloneAndFill)(module.jsonToAugment, tplDataFlat);
+    // This is necessary because one layer of escaped backslashes is lost on template population.
+    const clonedTplData = Object.assign({}, tplData);
+    clonedTplData.params = Object.fromEntries(Object.entries(paramVals).map(([k, v]) => [k, typeof v === 'string' ? v.replace('\\', '\\\\') : v]));
     for (const jsonPath of Object.keys(jsonPaths)) {
-        const scaffoldContents = (0, read_tpl_1.readTpl)((0, path_1.resolve)(scaffoldDir, jsonPath), tplData);
+        const scaffoldContents = (0, read_tpl_1.readTpl)((0, path_1.resolve)(scaffoldDir, jsonPath), clonedTplData);
         const scaffoldContentsJson = JSON.parse(scaffoldContents);
         const excludeKeys = (0, clone_and_fill_1.cloneAndFill)((_b = excludeScaffolding.configKeys[jsonPath]) !== null && _b !== void 0 ? _b : [], tplDataFlat);
         const fieldsToAugment = jsonPaths[jsonPath].filter((key) => !excludeKeys.includes(key));

package/lib/boilersmith/scaffolding/scaffolder.d.ts

@@ -4,7 +4,7 @@ import { DefaultProviders, Step } from '../step-manager';
 import { Module, ModuleStatusCache } from './module';
 import { TemplateParam } from './template-param';
 import { IO } from 'boilersmith/io';
-export declare type ExcludeScaffoldingFunc = (fs: Store, paths: Paths) => {
+export type ExcludeScaffoldingFunc = (fs: Store, paths: Paths) => {
     files: string[];
     configKeys: Record<string, string[]>;
 };

package/lib/boilersmith/scaffolding/scaffolder.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Scaffolder = void 0;
 const tslib_1 = require("tslib");
-const globby_1 = (0, tslib_1.__importDefault)(require("globby"));
+const globby_1 = tslib_1.__importDefault(require("globby"));
 const path_1 = require("path");
 const json_leaf_paths_1 = require("boilersmith/utils/json-leaf-paths");
 const read_tpl_1 = require("boilersmith/utils/read-tpl");

package/lib/boilersmith/scaffolding/template-param.d.ts

@@ -14,7 +14,7 @@ interface ComputedTemplateParam<T, N extends string = string> {
     uses: N[];
     compute: (paths: Paths, ...args: any[]) => Promise<T>;
 }
-export declare type TemplateParam<T = unknown, N extends string = string> = PromptTemplateParam<T, N> | ComputedTemplateParam<T, N>;
+export type TemplateParam<T = unknown, N extends string = string> = PromptTemplateParam<T, N> | ComputedTemplateParam<T, N>;
 export declare function isPromptParam<T, N extends string>(param: TemplateParam<T, N>): param is PromptTemplateParam<T, N>;
 export declare function isComputedParam<T, N extends string>(param: TemplateParam<T, N>): param is ComputedTemplateParam<T, N>;
 export declare function getParamName<T, N extends string>(param: TemplateParam<T, N>): N;

package/lib/boilersmith/step-manager.d.ts

@@ -2,7 +2,7 @@ import { Store } from 'mem-fs';
 import { ExposedParamManager } from './exposed-param-manager';
 import { IO, Message } from './io';
 import { Paths } from './paths';
-export declare type DefaultProviders = {};
+export type DefaultProviders = {};
 export interface Step<Providers extends DefaultProviders = DefaultProviders, Exposes extends string = string> {
     /**
      * A short string describing what the step does.
@@ -26,12 +26,13 @@ export interface Step<Providers extends DefaultProviders = DefaultProviders, Exp
      */
     getExposed(paths: Paths, io: IO): Record<Exposes, unknown>;
 }
-interface ShouldRunConfig {
+export interface ShouldRunConfig {
     optional?: boolean;
     confirmationMessage?: string;
     default?: boolean;
+    silent?: boolean;
 }
-interface StoredStep<Providers extends DefaultProviders> {
+export interface StoredStep<Providers extends DefaultProviders> {
     name?: string;
     step: Step<Providers>;
     shouldRun: ShouldRunConfig;
@@ -39,15 +40,16 @@ interface StoredStep<Providers extends DefaultProviders> {
     predefinedParams: PredefinedParameters;
     mapPaths: string[];
 }
-interface StepDependency {
+export interface StepDependency {
     sourceStep: string;
     exposedName: string;
     consumedName?: string;
     dontRunIfFalsy?: boolean;
+    promptWhenMissing?: boolean;
     modifier?: (value: unknown) => string;
 }
-declare type PredefinedParameters = Record<string, unknown>;
-declare type StepsResult = {
+export type PredefinedParameters = Record<string, unknown>;
+type StepsResult = {
     succeeded: true;
     messages: Message[];
     stepsRan: string[];
@@ -57,28 +59,31 @@ declare type StepsResult = {
     errorTrace?: string;
     messages: Message[];
     stepsRan: string[];
+    e?: any;
 };
 export declare class StepManager<Providers extends DefaultProviders> {
     protected steps: Array<StoredStep<Providers> | AtomicStepManager<Providers>>;
     protected namedSteps: Map<string, StoredStep<Providers>>;
     protected exposedParams: ExposedParamManager;
+    private silent;
     /**
      * A step is an incremental operation that updates the filesystem.
      */
     step(step: Step<Providers>, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[], predefinedParams?: PredefinedParameters, mapPaths?: string[]): this;
     namedStep(name: string, step: Step<Providers>, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[], predefinedParams?: PredefinedParameters, mapPaths?: string[]): this;
     atomicGroup(callback: (stepManager: AtomicStepManager<Providers>) => void): this;
+    silentGroup(callback: (stepManager: StepManager<Providers>) => void): this;
     protected validateDependencies(step: Step<Providers>, dependencies: StepDependency[], mapPaths: string[]): void;
-    run(paths: Paths, io: IO, providers: Providers, dry?: boolean): Promise<StepsResult>;
+    run(paths: Paths, io: IO, providers: Providers, dry?: boolean, args?: Record<string, unknown>): Promise<StepsResult>;
     protected stepShouldRun(storedStep: StoredStep<Providers>, io: IO, packagePath?: string): Promise<boolean>;
-    protected runStep(storedStep: StoredStep<Providers>, paths: Paths, io: IO, providers: Providers, packagePath?: string, fs?: Store): Promise<Store>;
+    protected runStep(storedStep: StoredStep<Providers>, paths: Paths, io: IO, providers: Providers, packagePath?: string, fs?: Store, args?: Record<string, unknown>): Promise<Store>;
 }
-export declare class AtomicStepManager<Providers = DefaultProviders> extends StepManager<Providers> {
+export declare class AtomicStepManager<Providers extends DefaultProviders> extends StepManager<Providers> {
     protected steps: StoredStep<Providers>[];
     constructor(parentNamedSteps?: Map<string, StoredStep<Providers>>, parentExposedParams?: ExposedParamManager);
     step(step: Step<Providers>, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[], predefinedParams?: PredefinedParameters, mapPaths?: string[]): this;
     namedStep(name: string, step: Step<Providers>, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[], predefinedParams?: PredefinedParameters, mapPaths?: string[]): this;
     atomicGroup(_callback: (stepManager: AtomicStepManager<Providers>) => void): this;
-    run(paths: Paths, io: IO, providers: Providers, dry?: boolean): Promise<StepsResult>;
+    run(paths: Paths, io: IO, providers: Providers, dry?: boolean, args?: Record<string, unknown>): Promise<StepsResult>;
 }
 export {};