@sanity/workflow-cli 0.8.0 → 0.9.0

package/dist/commands/definition/show.js

@@ -1,24 +1,11 @@
 import { styleText } from 'node:util';
 import { Args, Command, Flags } from '@oclif/core';
-import { isTerminalStage, WORKFLOW_DEFINITION_TYPE, tagScopeFilter, } from '@sanity/workflow-engine';
+import { isTerminalStage, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
-import { loadClient } from "../../lib/client.js";
+import { resolveReadContext } from "../../lib/context.js";
+import { buildDefinitionShowQuery } from "../../lib/definitions.js";
 import { tagFlags } from "../../lib/flags.js";
 import { formatKeyValue, sectionHeader } from "../../lib/ui.js";
-export function buildDefinitionShowQuery(flags) {
-    const params = { name: flags.name };
-    const filters = [`_type == "${WORKFLOW_DEFINITION_TYPE}"`, 'name == $name'];
-    if (flags.version !== undefined) {
-        params.version = flags.version;
-        filters.push('version == $version');
-    }
-    if (flags.tag) {
-        params.tag = flags.tag;
-        filters.push(tagScopeFilter());
-    }
-    const groq = `*[${filters.join(' && ')}] | order(version desc) [0]`;
-    return { groq, params };
-}
 export default class DefinitionShow extends Command {
     static description = 'Show a deployed workflow definition.';
     static args = {
@@ -30,12 +17,12 @@ export default class DefinitionShow extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(DefinitionShow);
+        const { client } = await resolveReadContext(flags);
         const { groq, params } = buildDefinitionShowQuery({
             name: args.name,
             tag: flags.tag,
             version: flags.version,
         });
-        const client = loadClient();
         // A deployed document: the authored {@link WorkflowDefinition} plus the
         // deploy-stamped envelope (`version`, `contentHash`, `tag`).
         const def = await client.fetch(groq, params);
@@ -57,11 +44,15 @@ const HEADER_PAD = 11; // "Description" — the longest label in the block
  *  authored definition, so it's passed separately and omitted when unknown. */
 export function definitionHeader(def, tag) {
     const rows = [
-        formatKeyValue('Title', def.title, { padTo: HEADER_PAD }),
-        formatKeyValue('Description', def.description ?? styleText('dim', '—'), { padTo: HEADER_PAD }),
+        formatKeyValue({ key: 'Title', value: def.title, padTo: HEADER_PAD }),
+        formatKeyValue({
+            key: 'Description',
+            value: def.description ?? styleText('dim', '—'),
+            padTo: HEADER_PAD,
+        }),
     ];
     if (tag !== undefined) {
-        rows.push(formatKeyValue('Tag', tag, { padTo: HEADER_PAD }));
+        rows.push(formatKeyValue({ key: 'Tag', value: tag, padTo: HEADER_PAD }));
     }
     return [styleText('bold', `${def.name} v${def.version}`), ...rows].join('\n');
 }

package/dist/commands/deploy.d.ts

@@ -1,22 +1,75 @@
 import { Command } from '@oclif/core';
+import { type DeployDefinitionResult, type WorkflowDefinition, type WorkflowDeployment } from '@sanity/workflow-engine';
+/** A deployment paired with the definitions selected + validated for it. */
+interface DeployBatch {
+    deployment: WorkflowDeployment;
+    defs: WorkflowDefinition[];
+}
+/** A deployment whose deploy/diff threw, kept for the closing summary. */
+interface DeployFailure {
+    deployment: Pick<WorkflowDeployment, 'name' | 'tag'>;
+    message: string;
+}
 export default class Deploy extends Command {
     static description: string;
     static examples: string[];
     static flags: {
+        'all-tags': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         check: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         only: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
+    private processDeployment;
     private executeDeploy;
     private runDryRun;
 }
 /** Reject the contradictory `--check --dry-run` combination. */
 export declare function validateModeFlags(check: boolean, dryRun: boolean): void;
+/**
+ * Select and validate every deployment's definitions up front. Validation runs
+ * before any network write ({@link validateOrFail} exits on a bad definition),
+ * so a whole-config deploy can never leave a partial reconcile behind a broken
+ * batch. In a multi-deployment run the failure names its deployment — it exits
+ * before any banner could attribute it.
+ */
+export declare function buildBatches(deployments: WorkflowDeployment[], only: string | undefined): DeployBatch[];
+/**
+ * Run `processBatch` over each batch, continuing past a failure so one bad
+ * deployment can't strand the rest — deployments are independent, and deploys
+ * are idempotent, so a partial run is safe to re-run. Failures are flattened
+ * to their message for {@link deploySummary}. A single-batch run rethrows
+ * instead: it has no summary, so a throw from before the deploy spinner starts
+ * would otherwise surface nowhere — and propagating keeps the stack visible.
+ */
+export declare function reconcileBatches({ batches, log, processBatch, }: {
+    batches: DeployBatch[];
+    log: (line: string) => void;
+    processBatch: (batch: DeployBatch) => Promise<void>;
+}): Promise<DeployFailure[]>;
+/**
+ * The closing summary for a multi-deployment run that had failures: the
+ * succeeded/failed tally and each failed deployment. Empty for a clean run.
+ * The wording is mode-neutral because a `--dry-run` failure lands here too,
+ * where nothing was deployed. Single-batch runs never reach it — their lone
+ * failure rethrows out of {@link reconcileBatches}.
+ */
+export declare function deploySummary({ total, failures, }: {
+    total: number;
+    failures: DeployFailure[];
+}): string[];
+/**
+ * The banner printed above a deployment's output so a multi-deployment run is
+ * attributable. `undefined` for a single-target run — it keeps its original
+ * unprefixed output. A leading blank line separates every deployment after the
+ * first.
+ */
+export declare function deploymentBanner({ deployment, index, total, }: {
+    deployment: Pick<WorkflowDeployment, 'name' | 'tag'>;
+    index: number;
+    total: number;
+}): string | undefined;
 /** One line per deployed definition, symbol-tagged by its result status. */
-export declare function deployResultLines(results: {
-    status: string;
-    definition: string;
-    version: number;
-}[]): string[];
+export declare function deployResultLines(results: DeployDefinitionResult[]): string[];
+export {};

package/dist/commands/deploy.js

@@ -1,23 +1,31 @@
+import { styleText } from 'node:util';
 import { Command, Flags } from '@oclif/core';
-import { computeDiffEntries, workflow } from '@sanity/workflow-engine';
+import { computeDiffEntries, workflow, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
 import ora from 'ora';
-import { buildClient, loadClient } from "../lib/client.js";
-import { loadWorkflowConfig } from "../lib/config.js";
-import { loadValidatedDefinitions } from "../lib/definitions.js";
+import { clientFor, resolveTokenOrFail } from "../lib/client.js";
+import { selectDefinitions, validateOrFail } from "../lib/definitions.js";
 import { diffReport } from "../lib/diff.js";
-import { fail } from "../lib/fail.js";
+import { errorMessage, fail } from "../lib/fail.js";
 import { tagFlags } from "../lib/flags.js";
+import { loadWorkflowConfig } from "../lib/load-config.js";
+import { deploymentToTarget, selectDeployments } from "../lib/select-deployment.js";
 export default class Deploy extends Command {
-    static description = 'Validate, diff, and deploy workflow definitions to the configured dataset.';
+    static description = 'Validate, diff, and deploy workflow definitions to the resource bound by the selected deployment.';
     static examples = [
-        '<%= config.bin %> deploy',
+        '<%= config.bin %> deploy --tag prod',
+        '<%= config.bin %> deploy --all-tags',
         '<%= config.bin %> deploy --check',
         '<%= config.bin %> deploy --dry-run',
         '<%= config.bin %> deploy --only productLaunch',
     ];
     static flags = {
         ...tagFlags,
+        'all-tags': Flags.boolean({
+            description: 'Deploy every deployment in the config, not just one tag.',
+            default: false,
+            exclusive: ['tag'],
+        }),
         'dry-run': Flags.boolean({
             description: 'Validate + diff against the deployed version; do not write.',
             default: false,
@@ -27,53 +35,75 @@ export default class Deploy extends Command {
             default: false,
         }),
         only: Flags.string({
-            description: 'Limit deploy/check/diff to a single workflow definition by name.',
+            description: 'Limit deploy/check/diff to a single workflow definition by name. Every targeted deployment must contain it.',
         }),
     };
     async run() {
         const { flags } = await this.parse(Deploy);
         validateModeFlags(flags.check, flags['dry-run']);
-        const config = loadWorkflowConfig(flags.tag);
-        const selected = await loadValidatedDefinitions(flags.only);
+        const config = await loadWorkflowConfig();
+        // Validate every deployment up front (below), so a bad definition fails
+        // before any write — never a partial reconcile from a validation error.
+        const batches = buildBatches(selectDeployments(config, { tag: flags.tag, allTags: flags['all-tags'] }), flags.only);
+        const log = (line) => this.log(line);
+        // buildBatches already validated everything offline — --check only has to
+        // report that pass, so it never resolves a token or builds a client.
         if (flags.check) {
-            this.log(`${logSymbols.success} ${selected.length} definition(s) passed validation (check only — dataset not contacted).`);
+            await reconcileBatches({
+                batches,
+                log,
+                processBatch: async ({ defs }) => {
+                    log(`${logSymbols.success} ${defs.length} definition(s) passed validation (check only — dataset not contacted).`);
+                },
+            });
             return;
         }
-        const client = loadClient();
-        if (flags['dry-run']) {
-            await this.runDryRun(client, selected, config);
+        // One token up front, so an --all-tags run authenticates once, not per deployment.
+        const token = await resolveTokenOrFail();
+        const failures = await reconcileBatches({
+            batches,
+            log,
+            processBatch: ({ deployment, defs }) => this.processDeployment({ deployment, defs, dryRun: flags['dry-run'], token }),
+        });
+        for (const line of deploySummary({ total: batches.length, failures })) {
+            log(line);
+        }
+        if (failures.length > 0) {
+            this.exit(1);
+        }
+    }
+    async processDeployment({ deployment, defs, dryRun, token, }) {
+        const target = deploymentToTarget(deployment);
+        const client = clientFor(deployment.workflowResource, token);
+        if (dryRun) {
+            await this.runDryRun({ client, defs, target });
             return;
         }
-        await this.executeDeploy(client, selected, config);
+        await this.executeDeploy({ client, defs, target });
     }
-    async executeDeploy(client, defs, config) {
+    async executeDeploy({ client, defs, target, }) {
         const spinner = ora(`Deploying ${defs.length} definition(s)…`).start();
         try {
-            const { results } = await workflow.deployDefinitions({
-                workflowResource: config.workflowResource,
-                tag: config.tag,
-                client,
-                definitions: defs,
-            });
+            const { results } = await workflow.deployDefinitions({ ...target, client, definitions: defs });
             spinner.succeed(`Processed ${results.length} definition(s)`);
             for (const line of deployResultLines(results))
                 this.log(line);
         }
         catch (error) {
-            spinner.fail('Deploy failed');
+            spinner.fail(`Deploy failed — ${errorMessage(error)}`);
             throw error;
         }
     }
-    async runDryRun(client, defs, config) {
+    async runDryRun({ client, defs, target, }) {
         const spinner = ora(`Diffing ${defs.length} definition(s) against dataset…`).start();
         try {
-            const entries = await computeDiffEntries(client, defs, config);
+            const entries = await computeDiffEntries({ client, defs, target });
             spinner.succeed(`Diffed ${defs.length} definition(s)`);
             for (const line of diffReport(entries))
                 this.log(line);
         }
         catch (error) {
-            spinner.fail('Diff failed');
+            spinner.fail(`Diff failed — ${errorMessage(error)}`);
             throw error;
         }
     }
@@ -84,6 +114,83 @@ export function validateModeFlags(check, dryRun) {
         fail('Pass either --check or --dry-run, not both.');
     }
 }
+/** The one identity format for a deployment in output — banner, failure
+ *  summary, and validation attribution all render it the same way. */
+function deploymentLabel({ name, tag }) {
+    return `${name} (${tag})`;
+}
+/**
+ * Select and validate every deployment's definitions up front. Validation runs
+ * before any network write ({@link validateOrFail} exits on a bad definition),
+ * so a whole-config deploy can never leave a partial reconcile behind a broken
+ * batch. In a multi-deployment run the failure names its deployment — it exits
+ * before any banner could attribute it.
+ */
+export function buildBatches(deployments, only) {
+    return deployments.map((deployment) => {
+        const context = deployments.length > 1 ? `${deploymentLabel(deployment)} — ` : '';
+        const defs = selectDefinitions(deployment.definitions, { only, context });
+        validateOrFail(defs, context);
+        return { deployment, defs };
+    });
+}
+/**
+ * Run `processBatch` over each batch, continuing past a failure so one bad
+ * deployment can't strand the rest — deployments are independent, and deploys
+ * are idempotent, so a partial run is safe to re-run. Failures are flattened
+ * to their message for {@link deploySummary}. A single-batch run rethrows
+ * instead: it has no summary, so a throw from before the deploy spinner starts
+ * would otherwise surface nowhere — and propagating keeps the stack visible.
+ */
+export async function reconcileBatches({ batches, log, processBatch, }) {
+    const failures = [];
+    for (const [index, batch] of batches.entries()) {
+        const banner = deploymentBanner({ deployment: batch.deployment, index, total: batches.length });
+        if (banner !== undefined) {
+            log(banner);
+        }
+        try {
+            await processBatch(batch);
+        }
+        catch (error) {
+            if (batches.length === 1) {
+                throw error;
+            }
+            failures.push({ deployment: batch.deployment, message: errorMessage(error) });
+        }
+    }
+    return failures;
+}
+/**
+ * The closing summary for a multi-deployment run that had failures: the
+ * succeeded/failed tally and each failed deployment. Empty for a clean run.
+ * The wording is mode-neutral because a `--dry-run` failure lands here too,
+ * where nothing was deployed. Single-batch runs never reach it — their lone
+ * failure rethrows out of {@link reconcileBatches}.
+ */
+export function deploySummary({ total, failures, }) {
+    if (failures.length === 0) {
+        return [];
+    }
+    return [
+        '',
+        styleText('bold', `${total - failures.length} of ${total} deployments succeeded — ${failures.length} failed:`),
+        ...failures.map((f) => styleText('red', `  ${logSymbols.error} ${deploymentLabel(f.deployment)} — ${f.message}`)),
+    ];
+}
+/**
+ * The banner printed above a deployment's output so a multi-deployment run is
+ * attributable. `undefined` for a single-target run — it keeps its original
+ * unprefixed output. A leading blank line separates every deployment after the
+ * first.
+ */
+export function deploymentBanner({ deployment, index, total, }) {
+    if (total <= 1) {
+        return undefined;
+    }
+    const gap = index > 0 ? '\n' : '';
+    return `${gap}${styleText('bold', `▸ ${deploymentLabel(deployment)}`)}`;
+}
 /** One line per deployed definition, symbol-tagged by its result status. */
 export function deployResultLines(results) {
     const symbols = {
@@ -91,6 +198,6 @@ export function deployResultLines(results) {
     };
     return results.map((r) => {
         const symbol = symbols[r.status] ?? logSymbols.warning;
-        return `  ${symbol} ${r.status.padEnd(9)} ${r.definition} v${r.version}`;
+        return `  ${symbol} ${r.status.padEnd(9)} ${r.name} v${r.version}`;
     });
 }

package/dist/commands/diagnose.d.ts

@@ -8,7 +8,11 @@ import { type Diagnosis, type DiagnoseInput, type SuggestedRemediation } from '@
  * {@link SuggestedRemediation}s rather than re-deriving them, so the rendered
  * fix block and the `--json` output stay one computation.
  */
-export declare function renderDiagnosis(diagnosis: Diagnosis, input: DiagnoseInput, remediations: SuggestedRemediation[]): string[];
+export declare function renderDiagnosis({ diagnosis, input, remediations, }: {
+    diagnosis: Diagnosis;
+    input: DiagnoseInput;
+    remediations: SuggestedRemediation[];
+}): string[];
 export default class Diagnose extends Command {
     static description: string;
     static examples: string[];

package/dist/commands/diagnose.js

@@ -1,11 +1,10 @@
 import { styleText } from 'node:util';
-import { Args, Command, Flags } from '@oclif/core';
+import { Args, Command } from '@oclif/core';
 import { diagnoseInputFromEvaluation, workflow, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
-import { loadClient } from "../lib/client.js";
-import { loadWorkflowConfig } from "../lib/config.js";
-import { fail } from "../lib/fail.js";
-import { tagFlags } from "../lib/flags.js";
+import { resolveInstanceContext } from "../lib/context.js";
+import { errorMessage, fail } from "../lib/fail.js";
+import { jsonFlags, tagFlags } from "../lib/flags.js";
 import { formatTimestamp, sectionHeader, activityIcon } from "../lib/ui.js";
 import { instanceHeader } from "./show.js";
 function formatAssignee(a) {
@@ -121,23 +120,18 @@ function transitionUnevaluableDetail(transitions) {
             `that is missing or unreadable (GROQ null), so routing is held rather than`,
             `falling through. Make the data the filter reads readable — publish the`,
             `subject (or fill the field) — and the instance advances on its own; no`,
-            `move-stage needed.`,
+            `set-stage needed.`,
         ],
     };
 }
-const REMEDIATION_LABEL = {
-    'retry-effect': 'retry-effect',
-    'drain-effects': 're-run the effect drainer',
-    'reset-activity': 'reset-activity',
-    'set-stage': 'move-stage',
-    abort: 'abort',
-};
 /** Render the engine's structured remediations as the "suggested fix" block.
- *  Only the runnable ones reach here — {@link renderDiagnosis} filters out
- *  verbs the CLI can't yet perform so it never advertises a fix you can't run
- *  (the full set, planned verbs included, still rides `--json`). */
+ *  Verbs render under their engine names — the same vocabulary `--json`
+ *  emits, so scripts and humans read one language. Only runnable ones reach
+ *  here: {@link renderDiagnosis} filters on the engine's `available` flag,
+ *  so verbs that aren't callable engine operations yet never render as a
+ *  fix (the full set, planned verbs included, still rides `--json`). */
 function remediationLines(remediations) {
-    return remediations.map((r) => `  • ${REMEDIATION_LABEL[r.verb]} — ${r.rationale}`);
+    return remediations.map((r) => `  • ${r.verb} — ${r.rationale}`);
 }
 function causeDetail(cause) {
     switch (cause.kind) {
@@ -179,7 +173,7 @@ function statusLine(diagnosis) {
  * {@link SuggestedRemediation}s rather than re-deriving them, so the rendered
  * fix block and the `--json` output stay one computation.
  */
-export function renderDiagnosis(diagnosis, input, remediations) {
+export function renderDiagnosis({ diagnosis, input, remediations, }) {
     const lines = [statusLine(diagnosis)];
     const inFlight = diagnosis.state === 'progressing' ||
         diagnosis.state === 'waiting' ||
@@ -219,20 +213,16 @@ export default class Diagnose extends Command {
     };
     static flags = {
         ...tagFlags,
-        json: Flags.boolean({
-            description: 'Emit the structured diagnosis as JSON instead of rendered output.',
-            default: false,
-        }),
+        ...jsonFlags,
     };
     async run() {
         const { args, flags } = await this.parse(Diagnose);
-        const config = loadWorkflowConfig(flags.tag);
-        const client = loadClient();
+        const { client, scope } = await resolveInstanceContext(flags, args.instanceId);
         const { evaluation, diagnosis, remediations } = await workflow
             .diagnose({
             client,
-            tag: config.tag,
-            workflowResource: config.workflowResource,
+            tag: scope.tag,
+            workflowResource: scope.workflowResource,
             instanceId: args.instanceId,
             // Token-auth CLI can't hit /users/me; pin the same system actor the
             // write verbs use. Transition filters and activity status are actor-
@@ -242,7 +232,7 @@ export default class Diagnose extends Command {
             // specific assignee's.
             access: { actor: { kind: 'system', id: 'workflow-cli' } },
         })
-            .catch((error) => fail('diagnose failed:', error instanceof Error ? error.message : String(error)));
+            .catch((error) => fail('diagnose failed:', errorMessage(error)));
         const input = diagnoseInputFromEvaluation(evaluation);
         if (flags.json) {
             this.log(JSON.stringify({
@@ -255,7 +245,7 @@ export default class Diagnose extends Command {
         }
         this.log(instanceHeader(evaluation.instance));
         this.log('');
-        for (const line of renderDiagnosis(diagnosis, input, remediations)) {
+        for (const line of renderDiagnosis({ diagnosis, input, remediations })) {
             this.log(line);
         }
     }

package/dist/commands/fire-action.d.ts

@@ -1,46 +1,34 @@
 import { Command } from '@oclif/core';
 import { type AvailableAction } from '@sanity/workflow-engine';
-import { type RanOp } from '../lib/ops-report.ts';
-/**
- * Parse repeated `--param key=value` flags into a params object. Each
- * value is JSON-parsed so numbers/booleans/objects type correctly,
- * falling back to the raw string. The engine validates the result against
- * the action's declared param types.
- */
-export declare function parseParams(pairs: string[]): Record<string, unknown>;
+import { type WriteOutcome, type WriteReport } from '../lib/ops-report.ts';
 /**
  * The list-mode body: every action on the current stage's activities, marked
  * fireable or not (with the disabling reason), plus a hint showing the
  * flags to fire one. Pure so the populated/empty permutations assert
  * without a live evaluation.
  */
-export declare function renderAvailableActions(actions: AvailableAction[], stage: string, instanceId: string): string[];
-interface FireOutcome {
-    fired: boolean;
-    cascaded: number;
-    instance: {
-        currentStage: string;
-    };
-    ranOps?: RanOp[];
-}
+export declare function renderAvailableActions({ actions, stage, instanceId, }: {
+    actions: AvailableAction[];
+    stage: string;
+    instanceId: string;
+}): string[];
 /** The `--json` payload for a fired action — the structured counterpart of
  *  {@link fireActionReport}. Pure so its shape is asserted directly. */
-export declare function fireResultJson(result: FireOutcome, ids: {
+export declare function fireResultJson(result: WriteOutcome, ids: {
     instanceId: string;
     activity: string;
     action: string;
 }): Record<string, unknown>;
-export interface FireActionReport {
-    fired: boolean;
-    message: string;
-    opsLines: string[];
-}
 /**
  * Turn a `fireAction` result into the spinner message + ops block. Pure so
  * the fired / no-op / cascaded / ops permutations assert without a live
  * fire.
  */
-export declare function fireActionReport(result: FireOutcome, activity: string, action: string): FireActionReport;
+export declare function fireActionReport({ result, activity, action, }: {
+    result: WriteOutcome;
+    activity: string;
+    action: string;
+}): WriteReport;
 export default class FireAction extends Command {
     static description: string;
     static examples: string[];
@@ -48,16 +36,15 @@ export default class FireAction extends Command {
         instanceId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        as: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'as-role': import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
         activity: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         action: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         param: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
-        as: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'as-role': import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
-        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
     private listActions;
     private fireOne;
 }
-export {};