@hyperdrive.bot/cli 1.0.2

package/dist/commands/parameter/add.js

@@ -0,0 +1,99 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { existsSync, readFileSync } from 'node:fs';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class ParameterAdd extends Command {
+    static description = 'Add a new parameter to SSM Parameter Store';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --key="API_URL" --value="https://api.example.com" --stage="dev"',
+        '<%= config.bin %> <%= command.id %> --key="DB_HOST" --value="localhost" --specific',
+        '<%= config.bin %> <%= command.id %> --key="PORT" --value="3000"',
+    ];
+    static flags = {
+        accountId: Flags.string({
+            description: 'AWS Account ID',
+            env: 'AWS_ACCOUNT_ID',
+            required: true,
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        key: Flags.string({
+            char: 'k',
+            description: 'Parameter key/name',
+            required: true,
+        }),
+        moduleSlug: Flags.string({
+            char: 'm',
+            default() {
+                if (existsSync('.hyperdrive.json')) {
+                    const hyperdriveConfig = JSON.parse(readFileSync('.hyperdrive.json', 'utf8'));
+                    return hyperdriveConfig.slug;
+                }
+                return '';
+            },
+            description: 'Module slug',
+            required: true,
+        }),
+        specific: Flags.boolean({
+            default: false,
+            description: 'Make parameter specific to this project (default: global)',
+        }),
+        stage: Flags.string({
+            char: 's',
+            default: 'all',
+            description: 'Stage for the parameter (default: all stages)',
+        }),
+        value: Flags.string({
+            char: 'v',
+            description: 'Parameter value',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ParameterAdd);
+        const confirmation = await inquirer.prompt([
+            {
+                default: true,
+                message: chalk.yellow(`Add parameter ${chalk.cyan(flags.key)} = ${chalk.green(flags.value)} to ${flags.specific ? 'project-specific' : 'global'} parameters for stage ${chalk.cyan(flags.stage)}?`),
+                name: 'confirm',
+                type: 'confirm',
+            },
+        ]);
+        if (!confirmation.confirm) {
+            this.log(chalk.red('Operation cancelled.'));
+            return;
+        }
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            // Encode single parameter in key=value format
+            const paramContent = `${flags.key}=${flags.value}`;
+            const encodedContent = Buffer.from(paramContent).toString('base64');
+            const result = await service.parameterAdd({
+                accountId: flags.accountId,
+                encodedContent,
+                projectSlug: flags.moduleSlug, // API still expects projectSlug
+                specific: flags.specific,
+                stage: flags.stage,
+            });
+            if (result.errors && Array.isArray(result.errors) && result.errors.length > 0) {
+                this.log(chalk.red('❌ Failed to add parameter:'));
+                for (const error of result.errors) {
+                    this.log(chalk.red(`  - ${error.key}: ${error.error}`));
+                }
+            }
+            else {
+                this.log(chalk.green('✅ Parameter added successfully!'));
+                this.log(chalk.gray(`   Key: ${flags.key}`));
+                this.log(chalk.gray(`   Scope: ${flags.specific ? 'Project-specific' : 'Global'}`));
+                this.log(chalk.gray(`   Stage: ${flags.stage}`));
+            }
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error('An error occurred while adding the parameter');
+        }
+    }
+}

package/dist/commands/parameter/backfill.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class ParameterBackfill extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        accountId: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        domain: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'dry-run': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        'no-dry-run': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/parameter/backfill.js

@@ -0,0 +1,113 @@
+import { Command, Flags, ux } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class ParameterBackfill extends Command {
+    static description = 'Backfill existing SSM parameters to DynamoDB (one-time migration)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --accountId="123456789012" --dry-run',
+        '<%= config.bin %> <%= command.id %> --accountId="123456789012"',
+    ];
+    static flags = {
+        accountId: Flags.string({
+            description: 'AWS Account ID to backfill from',
+            env: 'AWS_ACCOUNT_ID',
+            required: true,
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        'dry-run': Flags.boolean({
+            default: true,
+            description: 'Preview what would be imported without making changes (default: true)',
+        }),
+        'no-dry-run': Flags.boolean({
+            default: false,
+            description: 'Actually perform the backfill (writes to DynamoDB)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ParameterBackfill);
+        // Determine if this is a dry run
+        const dryRun = flags['no-dry-run'] ? false : flags['dry-run'];
+        if (!dryRun) {
+            this.log(chalk.yellow('⚠️  This will import SSM parameters into DynamoDB.'));
+            this.log(chalk.gray('   Existing DynamoDB records will NOT be overwritten.'));
+            this.log('');
+            const confirmation = await inquirer.prompt([
+                {
+                    default: false,
+                    message: chalk.yellow('Are you sure you want to proceed with the backfill?'),
+                    name: 'confirm',
+                    type: 'confirm',
+                },
+            ]);
+            if (!confirmation.confirm) {
+                this.log(chalk.gray('Operation cancelled.'));
+                return;
+            }
+        }
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            this.log(chalk.blue(dryRun ? '🔍 Running dry run (preview only)...' : '📥 Starting backfill...'));
+            this.log(chalk.gray(`   Account: ${flags.accountId}`));
+            this.log('');
+            const result = await service.parameterBackfill({
+                accountId: flags.accountId,
+                dryRun,
+            });
+            if (result.totalFound === 0) {
+                this.log(chalk.yellow('⚠️  No parameters found in SSM for this tenant'));
+                return;
+            }
+            this.log(chalk.green(`✅ ${dryRun ? 'Dry run complete' : 'Backfill complete'}!`));
+            this.log('');
+            this.log(chalk.cyan('📊 Summary:'));
+            this.log(chalk.gray(`   Total found in SSM: ${result.totalFound}`));
+            this.log(chalk.green(`   ${dryRun ? 'Would import' : 'Imported'}: ${result.imported}`));
+            this.log(chalk.yellow(`   Skipped (already exist): ${result.skipped}`));
+            this.log(chalk.red(`   Errors: ${result.errors.length}`));
+            this.log('');
+            // Show parameters table if there are any
+            if (result.parameters.length > 0) {
+                this.log(chalk.cyan('📋 Parameters:'));
+                const tableData = result.parameters.slice(0, 50).map(p => ({
+                    key: p.key,
+                    project: p.projectSlug,
+                    stage: p.stage,
+                    status: p.imported ? chalk.green('✓') : chalk.yellow('skipped'),
+                }));
+                ux.table(tableData, {
+                    key: { header: 'Key', minWidth: 30 },
+                    project: { header: 'Project', minWidth: 15 },
+                    stage: { header: 'Stage', minWidth: 10 },
+                    status: { header: 'Status', minWidth: 10 },
+                });
+                if (result.parameters.length > 50) {
+                    this.log(chalk.gray(`   ... and ${result.parameters.length - 50} more`));
+                }
+            }
+            // Show errors if any
+            if (result.errors.length > 0) {
+                this.log('');
+                this.log(chalk.red('❌ Errors:'));
+                for (const error of result.errors.slice(0, 10)) {
+                    this.log(chalk.red(`   ${error.path}: ${error.error}`));
+                }
+                if (result.errors.length > 10) {
+                    this.log(chalk.gray(`   ... and ${result.errors.length - 10} more errors`));
+                }
+            }
+            if (dryRun && result.imported > 0) {
+                this.log('');
+                this.log(chalk.cyan('💡 To perform the actual backfill, run:'));
+                this.log(chalk.white(`   hd parameter backfill --accountId="${flags.accountId}" --no-dry-run`));
+            }
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error('An error occurred while backfilling parameters');
+        }
+    }
+}

package/dist/commands/parameter/clear.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class ParameterClear extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        accountId: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        domain: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        moduleSlug: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        specific: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        stage: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/parameter/clear.js

@@ -0,0 +1,95 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { existsSync, readFileSync } from 'node:fs';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class ParameterClear extends Command {
+    static description = 'Clear all parameters for a project and stage (DANGEROUS)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --stage="dev"',
+        '<%= config.bin %> <%= command.id %> --stage="prod" --specific --force',
+    ];
+    static flags = {
+        accountId: Flags.string({
+            description: 'AWS Account ID',
+            env: 'AWS_ACCOUNT_ID',
+            required: true,
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Skip confirmation prompt (DANGEROUS)',
+        }),
+        moduleSlug: Flags.string({
+            char: 'm',
+            default() {
+                if (existsSync('.hyperdrive.json')) {
+                    const hyperdriveConfig = JSON.parse(readFileSync('.hyperdrive.json', 'utf8'));
+                    return hyperdriveConfig.slug;
+                }
+                return '';
+            },
+            description: 'Module slug',
+            required: true,
+        }),
+        specific: Flags.boolean({
+            default: false,
+            description: 'Clear only project-specific parameters (default: global)',
+        }),
+        stage: Flags.string({
+            char: 's',
+            default: 'all',
+            description: 'Stage to clear parameters for',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ParameterClear);
+        if (!flags.force) {
+            this.log(chalk.red('⚠️  WARNING: This will delete ALL parameters for the specified scope!'));
+            const typeConfirmation = await inquirer.prompt([
+                {
+                    message: chalk.red('Type "DELETE" to confirm:'),
+                    name: 'confirmText',
+                    validate: (input) => input === 'DELETE' || 'You must type DELETE to confirm',
+                },
+            ]);
+            if (typeConfirmation.confirmText !== 'DELETE') {
+                this.log(chalk.yellow('Operation cancelled.'));
+                return;
+            }
+            const confirmation = await inquirer.prompt([
+                {
+                    default: false,
+                    message: chalk.red(`Are you ABSOLUTELY SURE you want to clear ALL ${flags.specific ? 'project-specific' : 'global'} parameters for stage ${chalk.cyan(flags.stage)}?`),
+                    name: 'confirm',
+                    type: 'confirm',
+                },
+            ]);
+            if (!confirmation.confirm) {
+                this.log(chalk.yellow('Operation cancelled.'));
+                return;
+            }
+        }
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            this.log(chalk.blue('🗑️  Clearing parameters...'));
+            await service.parameterClear({
+                accountId: flags.accountId,
+                projectSlug: flags.moduleSlug, // API still expects projectSlug
+                specific: flags.specific,
+                stage: flags.stage,
+            });
+            this.log(chalk.green('✅ All parameters cleared successfully!'));
+            this.log(chalk.gray(`   Scope: ${flags.specific ? 'Project-specific' : 'Global'}`));
+            this.log(chalk.gray(`   Stage: ${flags.stage}`));
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error('An error occurred while clearing parameters');
+        }
+    }
+}

package/dist/commands/parameter/list.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class ParameterList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        accountId: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'all-stages': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        domain: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        moduleSlug: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        specific: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        stage: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/parameter/list.js

@@ -0,0 +1,92 @@
+import { Command, Flags, ux } from '@oclif/core';
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'node:fs';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class ParameterList extends Command {
+    static description = 'List all parameters for a project and stage';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --stage="dev"',
+        '<%= config.bin %> <%= command.id %> --stage="prod" --specific',
+        '<%= config.bin %> <%= command.id %> --all-stages',
+    ];
+    static flags = {
+        accountId: Flags.string({
+            description: 'AWS Account ID',
+            env: 'AWS_ACCOUNT_ID',
+            required: true,
+        }),
+        'all-stages': Flags.boolean({
+            default: false,
+            description: 'List parameters from all stages',
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        moduleSlug: Flags.string({
+            char: 'm',
+            default() {
+                if (existsSync('.hyperdrive.json')) {
+                    const hyperdriveConfig = JSON.parse(readFileSync('.hyperdrive.json', 'utf8'));
+                    return hyperdriveConfig.slug;
+                }
+                return '';
+            },
+            description: 'Module slug',
+            required: true,
+        }),
+        specific: Flags.boolean({
+            default: false,
+            description: 'List only project-specific parameters',
+        }),
+        stage: Flags.string({
+            char: 's',
+            default: 'all',
+            description: 'Stage to list parameters for',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ParameterList);
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            this.log(chalk.blue('🔍 Fetching parameters...'));
+            const result = await service.parameterList({
+                accountId: flags.accountId,
+                projectSlug: flags.moduleSlug, // API still expects projectSlug
+                specific: flags.specific,
+                stage: flags.stage,
+            });
+            if (!result.parameters || Object.keys(result.parameters).length === 0) {
+                this.log(chalk.yellow('⚠️  No parameters found'));
+                return;
+            }
+            this.log(chalk.green(`✅ Found ${Object.keys(result.parameters).length} parameter(s)\n`));
+            // Display parameters in a table
+            const tableData = Object.entries(result.parameters).map(([key, value]) => ({
+                key,
+                value: value.substring(0, 50) + (value.length > 50 ? '...' : ''),
+            }));
+            ux.table(tableData, {
+                key: {
+                    header: 'Parameter Key',
+                    minWidth: 20,
+                },
+                value: {
+                    header: 'Value',
+                    minWidth: 30,
+                },
+            });
+            // Display summary
+            this.log(chalk.gray('\n📊 Summary:'));
+            if (result.pathsParametersCount) {
+                for (const [path, count] of Object.entries(result.pathsParametersCount)) {
+                    this.log(chalk.gray(`   ${path}: ${count} parameter(s)`));
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error('An error occurred while listing parameters');
+        }
+    }
+}

package/dist/commands/parameter/pull.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class ParameterPull extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        accountId: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        backup: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        domain: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        file: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        moduleSlug: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        stage: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/parameter/pull.js

@@ -0,0 +1,124 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { copyFileSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class ParameterPull extends Command {
+    static description = 'Pull parameters from SSM Parameter Store to a .env file';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --stage="dev"',
+        '<%= config.bin %> <%= command.id %> --stage="prod" --file=".env.prod"',
+        '<%= config.bin %> <%= command.id %> --stage="dev" --no-backup',
+    ];
+    static flags = {
+        accountId: Flags.string({
+            description: 'AWS Account ID',
+            env: 'AWS_ACCOUNT_ID',
+            required: true,
+        }),
+        backup: Flags.boolean({
+            allowNo: true,
+            default: true,
+            description: 'Create .env.backup before overwriting (default: true)',
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        file: Flags.string({
+            char: 'f',
+            default: '.env',
+            description: 'Output file path',
+        }),
+        moduleSlug: Flags.string({
+            char: 'm',
+            default() {
+                if (existsSync('.hyperdrive.json')) {
+                    const hyperdriveConfig = JSON.parse(readFileSync('.hyperdrive.json', 'utf8'));
+                    return hyperdriveConfig.slug;
+                }
+                return '';
+            },
+            description: 'Module slug',
+            required: true,
+        }),
+        stage: Flags.string({
+            char: 's',
+            description: 'Stage to pull parameters from',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ParameterPull);
+        const { accountId, backup, domain, file, moduleSlug, stage } = flags;
+        const envPath = path.resolve(process.cwd(), file);
+        try {
+            const service = new HyperdriveSigV4Service(domain);
+            this.log(chalk.blue('🔄 Pulling parameters from SSM...'));
+            this.log(chalk.gray(`   Module: ${moduleSlug}`));
+            this.log(chalk.gray(`   Stage: ${stage}`));
+            this.log(chalk.gray(`   Output: ${file}`));
+            // Fetch global parameters for this stage
+            const globalResult = await service.parameterList({
+                accountId,
+                projectSlug: moduleSlug,
+                specific: false,
+                stage,
+            });
+            // Fetch project-specific parameters for this stage
+            const specificResult = await service.parameterList({
+                accountId,
+                projectSlug: moduleSlug,
+                specific: true,
+                stage,
+            });
+            // Merge: project-specific overrides global
+            const mergedParams = {
+                ...globalResult.parameters,
+                ...specificResult.parameters,
+            };
+            const paramCount = Object.keys(mergedParams).length;
+            const globalCount = Object.keys(globalResult.parameters).length;
+            const specificCount = Object.keys(specificResult.parameters).length;
+            if (paramCount === 0) {
+                this.warn(chalk.yellow('No parameters found for this stage/module combination.'));
+                return;
+            }
+            this.log(chalk.gray(`   Found: ${globalCount} global, ${specificCount} project-specific`));
+            // Create backup if file exists and backup flag is true
+            if (backup && existsSync(envPath)) {
+                const backupPath = `${envPath}.backup`;
+                copyFileSync(envPath, backupPath);
+                this.log(chalk.gray(`   Backup: ${backupPath}`));
+            }
+            // Convert to .env format
+            const envContent = Object.entries(mergedParams)
+                .map(([key, value]) => {
+                // Check if value is already wrapped in matching quotes
+                const isAlreadySingleQuoted = value.startsWith("'") && value.endsWith("'") && value.length >= 2;
+                const isAlreadyDoubleQuoted = value.startsWith('"') && value.endsWith('"') && value.length >= 2;
+                if (isAlreadySingleQuoted || isAlreadyDoubleQuoted) {
+                    // Value is already quoted, use as-is
+                    return `${key}=${value}`;
+                }
+                // Only quote if value contains spaces, newlines, or shell special chars that need protection
+                const needsQuotes = /[\s\n\r]/.test(value) || value.includes('$') || value.includes('`');
+                if (needsQuotes) {
+                    // Use single quotes to avoid shell expansion, escape any single quotes in the value
+                    const escapedValue = value.replace(/'/g, "'\\''");
+                    return `${key}='${escapedValue}'`;
+                }
+                return `${key}=${value}`;
+            })
+                .sort()
+                .join('\n');
+            // Write to file
+            writeFileSync(envPath, envContent + '\n', 'utf8');
+            this.log(chalk.green(`\n✅ Successfully pulled ${paramCount} parameters to ${file}`));
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error('An error occurred while pulling parameters');
+        }
+    }
+}

package/dist/commands/parameter/remove.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class ParameterRemove extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        accountId: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        domain: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        key: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        moduleSlug: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        specific: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        stage: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}