heroku 9.0.0-alpha.1 → 9.0.0-alpha.3

package/lib/commands/spaces/vpn/wait.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const vpn_connections_1 = require("../../../lib/spaces/vpn-connections");
+const wait = (ms) => new Promise(resolve => {
+    setTimeout(resolve, ms);
+});
+class Wait extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Wait);
+        const { name, space, json } = flags;
+        const interval = (flags.interval ? Number.parseInt(flags.interval, 10) : 10) * 1000;
+        const timeout = (flags.timeout ? Number.parseInt(flags.timeout, 10) : 20 * 60) * 1000;
+        const deadline = new Date(Date.now() + timeout);
+        let { body: vpnConnection } = await this.heroku.get(`/spaces/${space}/vpn-connections/${name}`);
+        if (vpnConnection.status === 'active') {
+            core_1.ux.log('VPN has been allocated.');
+            return;
+        }
+        core_1.ux.action.start(`Waiting for VPN Connection ${color_1.default.green(name)} to allocate...`);
+        while (vpnConnection.status !== 'active') {
+            if (new Date() > deadline) {
+                core_1.ux.error('Timeout waiting for VPN to become allocated.', { exit: 1 });
+            }
+            if (vpnConnection.status === 'failed') {
+                core_1.ux.error(vpnConnection.status_message || '', { exit: 1 });
+            }
+            await wait(interval);
+            const { body: updatedVpnConnection } = await this.heroku.get(`/spaces/${space}/vpn-connections/${name}`);
+            vpnConnection = updatedVpnConnection;
+        }
+        core_1.ux.action.stop();
+        const { body: newVpnConnection } = await this.heroku.get(`/spaces/${space}/vpn-connections/${name}`);
+        if (json) {
+            core_1.ux.styledJSON(newVpnConnection);
+        }
+        else {
+            (0, vpn_connections_1.displayVPNConfigInfo)(space, name, newVpnConnection);
+        }
+    }
+}
+exports.default = Wait;
+Wait.topic = 'spaces';
+Wait.description = 'wait for VPN Connection to be created';
+Wait.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space the vpn connection belongs to', required: true }),
+    name: command_1.flags.string({ char: 'n', description: 'name or id of the vpn connection to wait for', required: true }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+    interval: command_1.flags.string({ char: 'i', description: 'seconds to wait between poll intervals' }),
+    timeout: command_1.flags.string({ char: 't', description: 'maximum number of seconds to wait' }),
+};

package/lib/commands/spaces/wait.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@heroku-cli/command';
+export default class Wait extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        interval: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        timeout: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        space: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    protected wait(ms: number): Promise<unknown>;
+    protected notify(spaceName: string): void;
+}

package/lib/commands/spaces/wait.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const spinner_1 = require("@oclif/core/lib/cli-ux/action/spinner");
+const debug_1 = require("debug");
+const spaces_1 = require("../../lib/spaces/spaces");
+const notifications_1 = require("@heroku-cli/notifications");
+const spacesDebug = (0, debug_1.default)('spaces:wait');
+class Wait extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Wait);
+        const spaceName = flags.space || args.space;
+        if (!spaceName) {
+            core_1.ux.error((0, tsheredoc_1.default)(`
+        Error: Missing 1 required arg:
+        space
+        See more help with --help
+      `));
+        }
+        const interval = flags.interval * 1000;
+        const timeout = flags.timeout * 1000;
+        const deadline = new Date(Date.now() + timeout);
+        const action = new spinner_1.default();
+        action.start(`Waiting for space ${color_1.default.green(spaceName)} to allocate`);
+        let headers = {};
+        if (!flags.json) {
+            headers = { 'Accept-Expansion': 'region' };
+        }
+        let { body: space } = await this.heroku.get(`/spaces/${spaceName}`, { headers });
+        while (space.state === 'allocating') {
+            if (new Date() > deadline) {
+                throw new Error('Timeout waiting for space to become allocated.');
+            }
+            await this.wait(interval);
+            const { body: updatedSpace } = await this.heroku.get(`/spaces/${spaceName}`, { headers });
+            space = updatedSpace;
+        }
+        try {
+            const { body: nat } = await this.heroku.get(`/spaces/${spaceName}/nat`);
+            space.outbound_ips = nat;
+        }
+        catch (error) {
+            spacesDebug(`Retrieving NAT details for the space failed with ${error}`);
+        }
+        action.stop();
+        (0, spaces_1.renderInfo)(space, flags.json);
+        this.notify(spaceName);
+    }
+    wait(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    notify(spaceName) {
+        try {
+            const notification = {
+                title: spaceName,
+                subtitle: `heroku spaces:wait ${spaceName}`,
+                message: 'space was successfully created',
+                sound: true,
+            };
+            (0, notifications_1.notify)(notification);
+        }
+        catch (error) {
+            core_1.ux.warn(error);
+        }
+    }
+}
+exports.default = Wait;
+Wait.topic = 'spaces';
+Wait.description = 'wait for a space to be created';
+Wait.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space to get info of' }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+    interval: command_1.flags.integer({
+        char: 'i',
+        description: 'seconds to wait between poll intervals',
+        default: 30,
+    }),
+    timeout: command_1.flags.integer({
+        char: 't',
+        description: 'maximum number of seconds to wait',
+        default: 25 * 60,
+    }),
+};
+Wait.args = {
+    space: core_1.Args.string({ hidden: true }),
+};

package/lib/commands/status.js

@@ -2,13 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const color_1 = require("@heroku-cli/color");
 const core_1 = require("@oclif/core");
+const util_1 = require("@oclif/core/lib/util");
 const date_fns_1 = require("date-fns");
 const http_call_1 = require("http-call");
-const util_1 = require("../lib/status/util");
-const capitalize = (str) => str.slice(0, 1).toUpperCase() + str.slice(1);
+const util_2 = require("../lib/status/util");
 const printStatus = (status) => {
     const colorize = color_1.default[status];
-    let message = capitalize(status);
+    let message = (0, util_1.capitalize)(status);
     if (status === 'green') {
         message = 'No known issues at this time.';
     }
@@ -31,7 +31,7 @@ class Status extends core_1.Command {
         for (const incident of body.incidents) {
             core_1.ux.log();
             core_1.ux.styledHeader(`${incident.title} ${color_1.default.yellow(incident.created_at)} ${color_1.default.cyan(incident.full_url)}`);
-            const padding = (0, util_1.maxBy)(incident.updates, (i) => i.update_type.length).update_type.length + 0;
+            const padding = (0, util_2.maxBy)(incident.updates, (i) => i.update_type.length).update_type.length + 0;
             for (const u of incident.updates) {
                 core_1.ux.log(`${color_1.default.yellow(u.update_type.padEnd(padding))} ${new Date(u.updated_at).toISOString()} (${(0, date_fns_1.formatDistanceToNow)(new Date(u.updated_at))} ago)`);
                 core_1.ux.log(`${u.contents}\n`);

package/lib/commands/teams/index.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@heroku-cli/command';
+export default class Index extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/teams/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+class Index extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Index);
+        const { body: teams } = await this.heroku.get('/teams');
+        if (flags.json)
+            core_1.ux.styledJSON(teams);
+        else {
+            core_1.ux.table(teams.sort((a, b) => {
+                const aName = (a === null || a === void 0 ? void 0 : a.name) || '';
+                const bName = (b === null || b === void 0 ? void 0 : b.name) || '';
+                return (aName > bName) ? 1 : ((bName > aName) ? -1 : 0);
+            }), {
+                name: { header: 'Team' },
+                role: { header: 'Role', get: ({ role }) => color_1.default.green(role || '') },
+            });
+        }
+    }
+}
+exports.default = Index;
+Index.topic = 'teams';
+Index.description = `list the teams that you are a member of\n\nUse ${color_1.default.cyan.bold('heroku members:*')} to manage team members.`;
+Index.flags = {
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+};

package/lib/global_telemetry.js

@@ -15,9 +15,12 @@ const path = require('path');
 const { version } = require('../package.json');
 const root = path.resolve(__dirname, '../package.json');
 const isDev = process.env.IS_DEV_ENVIRONMENT === 'true';
-const config = new core_1.Config({ root });
-const heroku = new command_1.APIClient(config);
-const token = heroku.auth;
+const isTelemetryDisabled = process.env.DISABLE_TELEMETRY === 'true';
+function getToken() {
+    const config = new core_1.Config({ root });
+    const heroku = new command_1.APIClient(config);
+    return heroku.auth;
+}
 const debug = require('debug')('global_telemetry');
 const rollbar = new Rollbar({
     accessToken: '20783109b0064dbb85be0b2c5a5a5f79',
@@ -38,7 +41,7 @@ const resource = Resource
 const provider = new NodeTracerProvider({
     resource,
 });
-const headers = { Authorization: `Bearer ${token}` };
+const headers = { Authorization: `Bearer ${process.env.IS_HEROKU_TEST_ENV !== 'true' ? getToken() : ''}` };
 const exporter = new OTLPTraceExporter({
     url: isDev ? 'https://backboard-staging.herokuapp.com/otel/v1/traces' : 'https://backboard.heroku.com/otel/v1/traces',
     headers,
@@ -104,6 +107,9 @@ function reportCmdNotFound(config) {
 exports.reportCmdNotFound = reportCmdNotFound;
 async function sendTelemetry(currentTelemetry, rollbarCb) {
     // send telemetry to honeycomb and rollbar
+    if (isTelemetryDisabled) {
+        return;
+    }
     const telemetry = currentTelemetry;
     if (telemetry instanceof Error) {
         await Promise.all([

package/lib/hooks/postrun/performance_analytics.js

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const telemetry = require("../../global_telemetry");
 const performance_analytics = async function () {
-    if (global.cliTelemetry) {
-        const cmdStartTime = global.cliTelemetry.commandRunDuration;
-        global.cliTelemetry.commandRunDuration = telemetry.computeDuration(cmdStartTime);
-        global.cliTelemetry.lifecycleHookCompletion.postrun = true;
+    if (process.env.IS_HEROKU_TEST_ENV === 'true' || !global.cliTelemetry) {
+        return;
     }
+    const cmdStartTime = global.cliTelemetry.commandRunDuration;
+    global.cliTelemetry.commandRunDuration = telemetry.computeDuration(cmdStartTime);
+    global.cliTelemetry.lifecycleHookCompletion.postrun = true;
 };
 exports.default = performance_analytics;

package/lib/hooks/prerun/analytics.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const analytics_1 = require("../../analytics");
 const telemetry = require("../../global_telemetry");
 const analytics = async function (options) {
+    if (process.env.IS_HEROKU_TEST_ENV === 'true') {
+        return;
+    }
     global.cliTelemetry = telemetry.setupTelemetry(this.config, options);
     const analytics = new analytics_1.default(this.config);
     await analytics.record(options);

package/lib/lib/addons/addons_wait.d.ts

@@ -0,0 +1,78 @@
+import * as Heroku from '@heroku-cli/schema';
+import { APIClient } from '@heroku-cli/command';
+export declare const waitForAddonProvisioning: (api: APIClient, addon: Heroku.AddOn, interval: number) => Promise<{
+    [x: string]: any;
+    actions?: {
+        [k: string]: any;
+    }[] | undefined;
+    addon_service?: {
+        [k: string]: any;
+        id?: string | undefined;
+        name?: string | undefined;
+    } | undefined;
+    billing_entity?: {
+        [k: string]: any;
+        id?: string | undefined;
+        name?: string | undefined;
+        type?: "app" | "team" | undefined;
+    } | undefined;
+    app?: {
+        [k: string]: any;
+        id?: string | undefined;
+        name?: string | undefined;
+    } | undefined;
+    billed_price?: {
+        [k: string]: any;
+    } | null | undefined;
+    config_vars?: string[] | undefined;
+    created_at?: string | undefined;
+    id?: string | undefined;
+    name?: string | undefined;
+    plan?: {
+        [k: string]: any;
+        id?: string | undefined;
+        name?: string | undefined;
+    } | undefined;
+    provider_id?: string | undefined;
+    state?: "provisioned" | "provisioning" | "deprovisioned" | undefined;
+    updated_at?: string | undefined;
+    web_url?: string | null | undefined;
+}>;
+export declare const waitForAddonDeprovisioning: (api: APIClient, addon: Heroku.AddOn, interval: number) => Promise<{
+    [x: string]: any;
+    actions?: {
+        [k: string]: any;
+    }[] | undefined;
+    addon_service?: {
+        [k: string]: any;
+        id?: string | undefined;
+        name?: string | undefined;
+    } | undefined;
+    billing_entity?: {
+        [k: string]: any;
+        id?: string | undefined;
+        name?: string | undefined;
+        type?: "app" | "team" | undefined;
+    } | undefined;
+    app?: {
+        [k: string]: any;
+        id?: string | undefined;
+        name?: string | undefined;
+    } | undefined;
+    billed_price?: {
+        [k: string]: any;
+    } | null | undefined;
+    config_vars?: string[] | undefined;
+    created_at?: string | undefined;
+    id?: string | undefined;
+    name?: string | undefined;
+    plan?: {
+        [k: string]: any;
+        id?: string | undefined;
+        name?: string | undefined;
+    } | undefined;
+    provider_id?: string | undefined;
+    state?: "provisioned" | "provisioning" | "deprovisioned" | undefined;
+    updated_at?: string | undefined;
+    web_url?: string | null | undefined;
+}>;

package/lib/lib/addons/addons_wait.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForAddonDeprovisioning = exports.waitForAddonProvisioning = void 0;
+const core_1 = require("@oclif/core");
+const color_1 = require("@heroku-cli/color");
+const waitForAddonProvisioning = async function (api, addon, interval) {
+    var _a;
+    const app = ((_a = addon.app) === null || _a === void 0 ? void 0 : _a.name) || '';
+    const addonName = addon.name;
+    let addonBody = Object.assign({}, addon);
+    core_1.ux.action.start(`Creating ${color_1.default.addon(addonName || '')}`);
+    while (addonBody.state === 'provisioning') {
+        // eslint-disable-next-line no-promise-executor-return
+        await new Promise(resolve => setTimeout(resolve, interval * 1000));
+        const addonResponse = await api.get(`/apps/${app}/addons/${addonName}`, {
+            headers: { 'Accept-Expansion': 'addon_service,plan' },
+        });
+        addonBody = addonResponse === null || addonResponse === void 0 ? void 0 : addonResponse.body;
+    }
+    if (addonBody.state === 'deprovisioned') {
+        throw new Error(`The add-on was unable to be created, with status ${addonBody.state}`);
+    }
+    core_1.ux.action.stop();
+    return addonBody;
+};
+exports.waitForAddonProvisioning = waitForAddonProvisioning;
+const waitForAddonDeprovisioning = async function (api, addon, interval) {
+    var _a;
+    const app = ((_a = addon.app) === null || _a === void 0 ? void 0 : _a.name) || '';
+    const addonName = addon.name || '';
+    let addonResponse = Object.assign({}, addon);
+    core_1.ux.action.start(`Destroying ${color_1.default.addon(addonName)}`);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    while (addonResponse.state === 'deprovisioning') {
+        // eslint-disable-next-line no-promise-executor-return
+        await new Promise(resolve => setTimeout(resolve, interval * 1000));
+        await api.get(`/apps/${app}/addons/${addonName}`, {
+            headers: { 'Accept-Expansion': 'addon_service,plan' },
+        }).then(response => {
+            addonResponse = response === null || response === void 0 ? void 0 : response.body;
+        }).catch(function (error) {
+            var _a;
+            // Not ideal, but API deletes the record returning a 404 when deprovisioned.
+            if (error.statusCode === 404 || ((_a = error.http) === null || _a === void 0 ? void 0 : _a.statusCode) === 404) {
+                addonResponse.state = 'deprovisioned';
+            }
+            else {
+                throw error;
+            }
+        });
+    }
+    core_1.ux.action.stop();
+    return addonResponse;
+};
+exports.waitForAddonDeprovisioning = waitForAddonDeprovisioning;

package/lib/lib/addons/create_addon.d.ts

@@ -0,0 +1,7 @@
+import * as Heroku from '@heroku-cli/schema';
+import { APIClient } from '@heroku-cli/command';
+export default function (heroku: APIClient, app: string, plan: string, confirm: string | undefined, wait: boolean, options: {
+    name?: string;
+    config: Record<string, string | boolean>;
+    as?: string;
+}): Promise<Heroku.AddOn>;

package/lib/lib/addons/create_addon.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const color_1 = require("@heroku-cli/color");
+const util = require("./util");
+const addons_wait_1 = require("./addons_wait");
+function formatConfigVarsMessage(addon) {
+    const configVars = addon.config_vars || [];
+    if (configVars.length > 0) {
+        return `Created ${color_1.default.addon(addon.name || '')} as ${configVars.map((c) => color_1.default.configVar(c)).join(', ')}`;
+    }
+    return `Created ${color_1.default.addon(addon.name || '')}`;
+}
+// eslint-disable-next-line max-params
+async function default_1(heroku, app, plan, confirm, wait, options) {
+    async function createAddonRequest(confirmed) {
+        var _a;
+        const body = {
+            confirm: confirmed,
+            name: options.name,
+            config: options.config,
+            plan: { name: plan },
+            attachment: { name: options.as },
+        };
+        core_1.ux.action.start(`Creating ${plan} on ${color_1.default.app(app)}`);
+        const { body: addon } = await heroku.post(`/apps/${app}/addons`, {
+            body,
+            headers: {
+                'accept-expansion': 'plan',
+                'x-heroku-legacy-provider-messages': 'true',
+            },
+        });
+        core_1.ux.action.stop(color_1.default.green(util.formatPriceText(((_a = addon.plan) === null || _a === void 0 ? void 0 : _a.price) || '')));
+        return addon;
+    }
+    let addon = await util.trapConfirmationRequired(app, confirm, confirm => (createAddonRequest(confirm)));
+    if (addon.provision_message) {
+        core_1.ux.log(addon.provision_message);
+    }
+    if (addon.state === 'provisioning') {
+        if (wait) {
+            core_1.ux.log(`Waiting for ${color_1.default.addon(addon.name || '')}...`);
+            addon = await (0, addons_wait_1.waitForAddonProvisioning)(heroku, addon, 5);
+            core_1.ux.log(formatConfigVarsMessage(addon));
+        }
+        else {
+            core_1.ux.log(`${color_1.default.addon(addon.name || '')} is being created in the background. The app will restart when complete...`);
+            core_1.ux.log(`Use ${color_1.default.cmd('heroku addons:info ' + addon.name)} to check creation progress`);
+        }
+    }
+    else if (addon.state === 'deprovisioned') {
+        throw new Error(`The add-on was unable to be created, with status ${addon.state}`);
+    }
+    else {
+        core_1.ux.log(formatConfigVarsMessage(addon));
+    }
+    return addon;
+}
+exports.default = default_1;

package/lib/lib/addons/destroy_addon.d.ts

@@ -0,0 +1,3 @@
+import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export default function (heroku: APIClient, addon: Heroku.AddOn, force?: boolean, wait?: boolean): Promise<Heroku.AddOn>;

package/lib/lib/addons/destroy_addon.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const addons_wait_1 = require("./addons_wait");
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+async function default_1(heroku, addon, force = false, wait = false) {
+    const addonName = addon.name || '';
+    async function destroyAddonRequest() {
+        var _a, _b;
+        core_1.ux.action.start(`Destroying ${color_1.default.addon(addonName)} on ${color_1.default.app(((_a = addon.app) === null || _a === void 0 ? void 0 : _a.name) || '')}`);
+        const { body: addonDelete } = await heroku.delete(`/apps/${(_b = addon.app) === null || _b === void 0 ? void 0 : _b.id}/addons/${addon.id}`, {
+            headers: { 'Accept-Expansion': 'plan' },
+            body: { force },
+        }).catch(error => {
+            if (error.body && error.body.message) {
+                throw new Error(`The add-on was unable to be destroyed: ${error.body.message}.`);
+            }
+            else {
+                throw new Error(`The add-on was unable to be destroyed: ${error}.`);
+            }
+        });
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        if (addonDelete.state === 'deprovisioning') {
+            core_1.ux.action.stop(color_1.default.yellow('pending'));
+        }
+        core_1.ux.action.stop();
+        return addonDelete;
+    }
+    let addonResponse = await destroyAddonRequest();
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    if (addonResponse.state === 'deprovisioning') {
+        if (wait) {
+            core_1.ux.log(`Waiting for ${color_1.default.addon(addonName)}...`);
+            addonResponse = await (0, addons_wait_1.waitForAddonDeprovisioning)(heroku, addonResponse, 5);
+        }
+        else {
+            core_1.ux.log(`${color_1.default.addon(addonName)} is being destroyed in the background. The app will restart when complete...`);
+            core_1.ux.log(`Use ${color_1.default.cmd('heroku addons:info ' + addonName)} to check destruction progress`);
+        }
+    }
+    else if (addonResponse.state !== 'deprovisioned') {
+        throw new Error(`The add-on was unable to be destroyed, with status ${addonResponse.state}.`);
+    }
+    return addonResponse;
+}
+exports.default = default_1;

package/lib/lib/addons/resolve.d.ts

@@ -0,0 +1,38 @@
+import { APIClient } from '@heroku-cli/command';
+import type { AddOnAttachment } from '@heroku-cli/schema';
+import type { AddOnAttachmentWithConfigVarsAndPlan } from '../pg/types';
+export declare const appAddon: (heroku: APIClient, app: string, id: string, options?: AddOnAttachment) => Promise<AddOnAttachmentWithConfigVarsAndPlan>;
+export declare const addonResolver: (heroku: APIClient, app: string | undefined, id: string, options?: AddOnAttachment) => Promise<AddOnAttachmentWithConfigVarsAndPlan>;
+export declare const appAttachment: (heroku: APIClient, app: string | undefined, id: string, options?: {
+    addon_service?: string;
+    namespace?: string;
+}) => Promise<AddOnAttachment & {
+    addon: AddOnAttachmentWithConfigVarsAndPlan;
+}>;
+export declare const attachmentResolver: (heroku: APIClient, app: string | undefined, id: string, options?: {
+    addon_service?: string;
+    namespace?: string;
+}) => Promise<void | AddOnAttachment>;
+export declare function resolveAddon(...args: Parameters<typeof addonResolver>): ReturnType<typeof addonResolver>;
+export declare namespace resolveAddon {
+    var cache: Map<string, Promise<AddOnAttachmentWithConfigVarsAndPlan>>;
+}
+export declare class NotFound extends Error {
+    readonly statusCode = 404;
+    readonly message = "Couldn't find that addon.";
+}
+export declare class AmbiguousError extends Error {
+    readonly matches: {
+        name?: string;
+    }[];
+    readonly type: string;
+    readonly statusCode = 422;
+    readonly message: string;
+    readonly body: {
+        id: string;
+        message: string;
+    };
+    constructor(matches: {
+        name?: string;
+    }[], type: string);
+}