@heroku/skynet 1.13.0 → 2.0.0

package/dist/commands/allowlist/add.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@heroku-cli/command';
+export default class AddAllowlist extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        value: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        notes: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static hiddenAliases: string[];
+    run(): Promise<void>;
+}

package/dist/commands/allowlist/add.js

@@ -0,0 +1,34 @@
+import SkynetAPI from '../../lib/skynet.js';
+import { Command } from '@heroku-cli/command';
+import { color } from '@heroku-cli/color';
+import { Flags, ux } from '@oclif/core';
+export default class AddAllowlist extends Command {
+    static description = 'adds an app or user to the allowlist';
+    static examples = [
+        '$ heroku skynet:allowlist:add -v foo@bar.com -n Additional info'
+    ];
+    static flags = {
+        value: Flags.string({
+            name: 'value',
+            char: 'v',
+            description: 'app name or user email to allowlist',
+            hasValue: true,
+            required: true
+        }),
+        notes: Flags.string({
+            name: 'notes',
+            char: 'n',
+            description: 'additional information for the allowlist entry',
+            hasValue: true,
+            required: true
+        })
+    };
+    static hiddenAliases = ['allowlist:append'];
+    async run() {
+        const { flags } = await this.parse(AddAllowlist);
+        const skynet = new SkynetAPI(this.heroku.auth);
+        ux.action.start(`adding ${color.cyan(flags.value)} to allowlist with ${color.cyan(flags.notes)}`);
+        await skynet.addAllowlist(flags.value, flags.notes);
+        ux.action.stop();
+    }
+}

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

@@ -0,0 +1,10 @@
+import { Command } from '@heroku-cli/command';
+export default class RemoveAllowlist extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        value: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static hiddenAliases: string[];
+    run(): Promise<void>;
+}

package/dist/commands/allowlist/remove.js

@@ -0,0 +1,27 @@
+import SkynetAPI from '../../lib/skynet.js';
+import { Command } from '@heroku-cli/command';
+import { color } from '@heroku-cli/color';
+import { Flags, ux } from '@oclif/core';
+export default class RemoveAllowlist extends Command {
+    static description = 'Remove user or app from the allowlist';
+    static examples = [
+        '$ heroku skynet:allowlist:remove -v foo@bar.com'
+    ];
+    static flags = {
+        value: Flags.string({
+            name: 'value',
+            char: 'v',
+            description: 'app name or user email to remove from allowlist',
+            hasValue: true,
+            required: true
+        })
+    };
+    static hiddenAliases = ['allowlist:remove'];
+    async run() {
+        const { flags } = await this.parse(RemoveAllowlist);
+        const skynet = new SkynetAPI(this.heroku.auth);
+        ux.action.start(`removing ${color.cyan(flags.value)} from allowlist`);
+        await skynet.removeAllowlist(flags.value);
+        ux.action.stop();
+    }
+}

package/dist/commands/allowlists.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@heroku-cli/command';
+export default class Allowlists extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {};
+    run(): Promise<void>;
+}

package/dist/commands/allowlists.js

@@ -0,0 +1,24 @@
+import SkynetAPI from '../lib/skynet.js';
+import { Command } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+export default class Allowlists extends Command {
+    static description = 'allowlists used by skynet';
+    static examples = [
+        '$ heroku skynet:allowlists'
+    ];
+    static flags = {};
+    async run() {
+        const skynet = new SkynetAPI(this.heroku.auth);
+        let response = await skynet.allowlists();
+        response = JSON.parse(response);
+        if (Object.keys(response).length > 0) {
+            ux.table(response, {
+                Value: {},
+                Notes: {},
+                CreatedAt: {},
+                UpdatedAt: {},
+                DeletedAt: {}
+            });
+        }
+    }
+}

package/dist/commands/categories/add.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@heroku-cli/command';
+export default class AddCategory extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/categories/add.js

@@ -0,0 +1,33 @@
+import SkynetAPI from '../../lib/skynet.js';
+import { Command } from '@heroku-cli/command';
+import { color } from '@heroku-cli/color';
+import { Flags, ux } from '@oclif/core';
+export default class AddCategory extends Command {
+    static description = '(requires sudo) Adds a category for use when suspending or deprovisioning';
+    static examples = [
+        '$ heroku skynet:categories:add -n Cryptominer -d "Abusers running cryptomining on the platform"'
+    ];
+    static flags = {
+        name: Flags.string({
+            name: 'name',
+            char: 'n',
+            description: 'The name of the category',
+            hasValue: true,
+            required: true
+        }),
+        description: Flags.string({
+            name: 'description',
+            char: 'd',
+            description: 'The description of the category',
+            hasValue: true,
+            required: true
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(AddCategory);
+        const skynet = new SkynetAPI(this.heroku.auth);
+        ux.action.start(`adding ${color.cyan(flags.name)} to categories with description ${color.cyan(flags.description)}`);
+        await skynet.addCategory(flags.name, flags.description);
+        ux.action.stop();
+    }
+}

package/dist/commands/categories/get.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@heroku-cli/command';
+export default class GetCategories extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {};
+    run(): Promise<void>;
+}

package/dist/commands/categories/get.js

@@ -0,0 +1,19 @@
+import SkynetAPI from '../../lib/skynet.js';
+import { Command } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+export default class GetCategories extends Command {
+    static description = '(requires sudo) categories to use for suspension and deprovisions';
+    static examples = [
+        '$ heroku skynet:categories'
+    ];
+    static flags = {};
+    async run() {
+        const skynet = new SkynetAPI(this.heroku.auth);
+        let response = await skynet.categories();
+        response = JSON.parse(response);
+        ux.table(response, {
+            Category: {},
+            Description: {}
+        });
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from '@heroku-cli/command';
+export default class RemoveCategory extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/categories/remove.js

@@ -0,0 +1,26 @@
+import SkynetAPI from '../../lib/skynet.js';
+import { Command } from '@heroku-cli/command';
+import { color } from '@heroku-cli/color';
+import { Flags, ux } from '@oclif/core';
+export default class RemoveCategory extends Command {
+    static description = '(requires sudo) Removes a category from Skynet';
+    static examples = [
+        '$ heroku skynet:categories:remove -n Cryptominer'
+    ];
+    static flags = {
+        name: Flags.string({
+            name: 'name',
+            char: 'n',
+            description: 'The name of the category',
+            hasValue: true,
+            required: true
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(RemoveCategory);
+        const skynet = new SkynetAPI(this.heroku.auth);
+        ux.action.start(`removing ${color.cyan(flags.name)} from categories`);
+        await skynet.removeCategory(flags.name);
+        ux.action.stop();
+    }
+}

package/dist/commands/deprovision.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Deprovision extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        user: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        category: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        notes: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        bypass: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        notify: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        'no-notify': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/deprovision.js

@@ -0,0 +1,80 @@
+import SkynetAPI from '../lib/skynet.js';
+import { requireSudo } from '../lib/sudo.js';
+import { Command } from '@heroku-cli/command';
+import { color } from '@heroku-cli/color';
+import { Flags, ux } from '@oclif/core';
+export default class Deprovision extends Command {
+    static description = '(requires sudo) suspends a user and deprovisions all addons';
+    static examples = [
+        '$ heroku skynet:deprovision -u foo@bar.com -n "helpful suspend message" -c "spam"'
+    ];
+    static flags = {
+        user: Flags.string({
+            name: 'user',
+            char: 'u',
+            description: 'user to deprovision',
+            hasValue: true
+        }),
+        category: Flags.string({
+            name: 'category',
+            char: 'c',
+            description: 'suspension category',
+            hasValue: true,
+            required: true
+        }),
+        notes: Flags.string({
+            name: 'notes',
+            char: 'n',
+            description: 'suspend notes',
+            hasValue: true,
+            required: true
+        }),
+        bypass: Flags.boolean({
+            name: 'bypass',
+            description: 'force suspension, bypassing skynet safety checks',
+            required: false
+        }),
+        notify: Flags.boolean({
+            name: 'notify',
+            description: 'send user suspension email notification',
+            required: false
+        }),
+        'no-notify': Flags.boolean({
+            name: 'no-notify',
+            description: 'skip user suspension email notification',
+            required: false
+        })
+    };
+    async run() {
+        requireSudo();
+        const { flags } = await this.parse(Deprovision);
+        const skynet = new SkynetAPI(this.heroku.auth);
+        const user = flags.user || process.env.HEROKU_USER;
+        const notes = flags.notes;
+        const category = flags.category;
+        const force = flags.bypass || process.env.HEROKU_FORCE === '1';
+        // Handle notification logic inline since notifyOption was removed
+        let notify = true;
+        if (process.env.SKYNET_NOTIFICATION && process.env.SKYNET_NOTIFICATION === 'false') {
+            notify = false;
+        }
+        if (flags.notify && flags['no-notify']) {
+            throw new Error('Flag --notify and --no-notify could not use together');
+        }
+        if (flags['no-notify']) {
+            notify = false;
+        }
+        if (flags.notify) {
+            notify = true;
+        }
+        const notificationStatus = (notify) ? 'enabled' : 'disabled';
+        if (!user) {
+            throw new Error('Required flag: --user USER');
+        }
+        ux.action.start(`Deprovisioning ${color.cyan(user)}`);
+        let response = await skynet.deprovision(user, notes, category, notify, force);
+        ux.action.stop();
+        response = JSON.parse(response);
+        ux.log(`${color.cyan(response.status)}. ${response.message}. Notification ${notificationStatus}`);
+    }
+}

package/dist/commands/suspend/app-owner.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class SuspendAppOwner extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        infile: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        category: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        notes: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        bypass: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        deprovision: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        async: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/suspend/app-owner.js

@@ -0,0 +1,87 @@
+import SkynetAPI from '../../lib/skynet.js';
+import * as utils from '../../lib/utils.js';
+import { requireSudo } from '../../lib/sudo.js';
+import { Command } from '@heroku-cli/command';
+import { color } from '@heroku-cli/color';
+import { Flags, ux } from '@oclif/core';
+import { processSuspensionResult } from '../../lib/utils.js';
+const chunkSize = 5;
+export default class SuspendAppOwner extends Command {
+    static description = '(requires sudo) suspends the owner of a given app';
+    static examples = [
+        '$ heroku skynet:suspend:app-owner -a foobar -n "helpful suspend message" -c "ddos"'
+    ];
+    static flags = {
+        app: Flags.string({
+            name: 'app',
+            char: 'a',
+            description: 'app that requires owner suspension',
+            hasValue: true
+        }),
+        infile: Flags.string({
+            name: 'infile',
+            char: 'i',
+            description: 'file of apps that require owner suspension',
+            hasValue: true
+        }),
+        category: Flags.string({
+            name: 'category',
+            char: 'c',
+            description: 'suspension category',
+            hasValue: true,
+            required: true
+        }),
+        notes: Flags.string({
+            name: 'notes',
+            char: 'n',
+            description: 'suspend notes',
+            hasValue: true,
+            required: true
+        }),
+        bypass: Flags.boolean({
+            name: 'bypass',
+            description: 'force suspension, bypassing skynet safety checks',
+            required: false
+        }),
+        deprovision: Flags.boolean({
+            name: 'deprovision',
+            char: 'd',
+            description: 'put user into the fast resource deletion flow',
+            required: false
+        }),
+        async: Flags.boolean({
+            name: 'async',
+            description: 'do not wait for suspension to complete',
+            required: false
+        })
+    };
+    async run() {
+        requireSudo();
+        const { flags } = await this.parse(SuspendAppOwner);
+        const skynet = new SkynetAPI(this.heroku.auth);
+        const app = flags.app;
+        const file = flags.infile;
+        const notes = flags.notes;
+        const category = flags.category;
+        const force = flags.bypass || process.env.HEROKU_FORCE === '1';
+        const deprovision = flags.deprovision;
+        if ((app && file) || (!app && !file)) {
+            ux.error('Either --app or --infile must be passed, but not both');
+        }
+        if (file) {
+            const apps = await utils.readlines(file);
+            const chunks = utils.arrayChunks(apps, chunkSize);
+            for (const chunk of chunks) {
+                ux.log('Suspending app owners: ' + chunk.join());
+                const response = await skynet.bulkSuspendAppOwner(apps.join(), notes, category, deprovision);
+                ux.log(`${color.cyan(response.status)}. ${response.message}`);
+            }
+        }
+        else {
+            ux.action.start(`Suspending app owner of ${color.cyan(app)}`);
+            let response = await skynet.suspendAppOwner(app, notes, category, force, deprovision, flags.async);
+            response = JSON.parse(response);
+            processSuspensionResult(app, response);
+        }
+    }
+}

package/dist/commands/suspend/apps.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class SuspendApp extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        notes: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        category: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        bypass: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        async: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/suspend/apps.js

@@ -0,0 +1,54 @@
+import SkynetAPI from '../../lib/skynet.js';
+import { requireSudo } from '../../lib/sudo.js';
+import { Command } from '@heroku-cli/command';
+import { color } from '@heroku-cli/color';
+import { Flags, ux } from '@oclif/core';
+import { processSuspensionResult } from '../../lib/utils.js';
+export default class SuspendApp extends Command {
+    static description = '(requires sudo) suspends an app';
+    static examples = [
+        '$ heroku skynet:suspend:app -a test-app -c "category" -n "helpful suspend message"'
+    ];
+    static flags = {
+        app: Flags.string({
+            name: 'app',
+            char: 'a',
+            description: 'app to suspend',
+            hasValue: true,
+            required: true
+        }),
+        notes: Flags.string({
+            name: 'notes',
+            char: 'n',
+            description: 'suspend notes',
+            hasValue: true,
+            required: true
+        }),
+        category: Flags.string({
+            name: 'category',
+            char: 'c',
+            description: 'suspension category',
+            hasValue: true,
+            required: true
+        }),
+        bypass: Flags.boolean({
+            name: 'bypass',
+            description: 'force suspension, bypassing skynet safety checks',
+            required: false
+        }),
+        async: Flags.boolean({
+            name: 'async',
+            description: 'do not wait for suspension to complete',
+            required: false
+        })
+    };
+    async run() {
+        requireSudo();
+        const { flags } = await this.parse(SuspendApp);
+        const skynet = new SkynetAPI(this.heroku.auth);
+        ux.action.start(color.blue.bold(`Suspending the app ${color.cyan(flags.app)}...`));
+        let response = await skynet.suspendApp(flags.app, flags.notes, flags.category, flags.bypass || process.env.HEROKU_FORCE === '1', flags.async);
+        response = JSON.parse(response);
+        processSuspensionResult(flags.app, response);
+    }
+}

package/dist/commands/suspend/user.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@heroku-cli/command';
+export default class SuspendUser extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        user: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        infile: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        category: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        notes: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        bypass: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        'no-notify': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        notify: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        deprovision: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        async: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/suspend/user.js

@@ -0,0 +1,110 @@
+import SkynetAPI from '../../lib/skynet.js';
+import { requireSudo } from '../../lib/sudo.js';
+import { Command } from '@heroku-cli/command';
+import { Flags, ux } from '@oclif/core';
+import { logError, processSuspensionResult } from '../../lib/utils.js';
+import { color } from '@heroku-cli/color';
+export default class SuspendUser extends Command {
+    static description = '(requires sudo) suspends a user';
+    static examples = [
+        '$ heroku sudo skynet:suspend:user -u foo@bar.com -n "helpful suspend message" -c "ddos"'
+    ];
+    static flags = {
+        user: Flags.string({
+            name: 'user',
+            char: 'u',
+            description: 'user to suspend',
+            hasValue: true
+        }),
+        infile: Flags.string({
+            name: 'infile',
+            char: 'i',
+            description: 'file of users to suspend',
+            hasValue: true
+        }),
+        category: Flags.string({
+            name: 'category',
+            char: 'c',
+            description: 'suspension category',
+            hasValue: true,
+            required: true
+        }),
+        notes: Flags.string({
+            name: 'notes',
+            char: 'n',
+            description: 'suspend notes',
+            hasValue: true,
+            required: true
+        }),
+        bypass: Flags.boolean({
+            name: 'bypass',
+            description: 'force suspension, bypassing skynet safety checks',
+            required: false
+        }),
+        'no-notify': Flags.boolean({
+            name: 'no-notify',
+            description: 'skip user suspension email notification',
+            required: false
+        }),
+        notify: Flags.boolean({
+            name: 'notify',
+            description: 'send user suspension email notification',
+            required: false
+        }),
+        deprovision: Flags.boolean({
+            name: 'deprovision',
+            char: 'd',
+            description: 'put user into the fast resource deletion flow',
+            required: false
+        }),
+        async: Flags.boolean({
+            name: 'async',
+            description: 'do not wait for suspension to complete',
+            required: false
+        })
+    };
+    async run() {
+        requireSudo();
+        const { flags } = await this.parse(SuspendUser);
+        const skynet = new SkynetAPI(this.heroku.auth);
+        const user = flags.user || process.env.HEROKU_USER;
+        const file = flags.infile;
+        const notes = flags.notes;
+        const category = flags.category;
+        const force = flags.bypass || process.env.HEROKU_FORCE === '1';
+        const deprovision = flags.deprovision;
+        if (flags.notify && flags.no_notify) {
+            ux.error('Flag --notify and --no-notify cannot be used together');
+        }
+        // Start with default notification setting from environment variable
+        let notify = process.env.SKYNET_NOTIFICATION !== 'false';
+        // Handle explicit flags (--notify/--no-notify)
+        if (flags['no-notify']) {
+            notify = false;
+        }
+        else if (flags.notify) {
+            notify = true;
+        }
+        if ((user && file) || (!user && !file)) {
+            ux.error('Either --user USER or --infile must be passed, but not both');
+        }
+        if (file) {
+            ux.action.start(color.blue.bold('Starting bulk suspend...'));
+            let response = await skynet.bulkSuspendUsers(file, notes, category, notify, force, deprovision);
+            response = JSON.parse(response);
+            if (response.statusCode === 200) {
+                ux.action.stop(color.green(`Bulk suspended users from ${file}. Please check slack for update on processing.`));
+            }
+            else {
+                logError(response);
+                ux.action.stop(color.bgRed(`Failed to bulk suspend users from ${file}`));
+            }
+        }
+        else {
+            ux.action.start(color.blue.bold(`Suspending user ${color.cyan(user)}...`));
+            let response = await skynet.suspendUser(user, notes, category, notify, force, deprovision, flags.async);
+            response = JSON.parse(response);
+            processSuspensionResult(user, response);
+        }
+    }
+}

package/dist/commands/suspensions.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@heroku-cli/command';
+export default class Suspensions extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        account: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}