@heroku/sdk 0.1.0-beta.0

package/dist/resources/platform/add-on/pricing.js

@@ -0,0 +1,100 @@
+/**
+ * 30-day month assumption used to convert monthly pricing to an
+ * effective hourly rate. Heroku's documented dyno/add-on pricing
+ * uses this convention, so consumers displaying "max $X/month
+ * (~$Y/hour)" should compute hourly the same way.
+ */
+const HOURS_PER_MONTH = 24 * 30;
+/**
+ * Break a plan's price down into monthly- and hourly-equivalent
+ * cents, normalizing across the API's billing unit. Consumers that
+ * display "max $X/month (~$Y/hour)" labels should call this rather
+ * than dividing `cents` by hours themselves; centralizing the math
+ * keeps the 30-day-month assumption (Heroku's documented convention)
+ * in one place.
+ *
+ * Returns `undefined` if the plan has no usable `price.cents` value.
+ * `Plan.price` is typed as optional in `@heroku/types`, and consumers
+ * occasionally receive partial responses depending on the Accept
+ * variant.
+ *
+ * `perMonthCents` and `perHourCents` are themselves `undefined` when
+ * the API reports a unit other than `'month'` or `'hour'` — callers
+ * should omit those parts of their label rather than show fabricated
+ * numbers.
+ *
+ * @param plan The plan to break down. Pass the whole `Plan` rather
+ *   than just `plan.price` so the helper can pick up future fields
+ *   without API churn at call sites.
+ */
+export function priceForPlan(plan) {
+    const { price } = plan;
+    if (!price || typeof price.cents !== 'number')
+        return undefined;
+    const { cents } = price;
+    const unit = price.unit ?? '';
+    let perMonthCents;
+    let perHourCents;
+    switch (unit) {
+        case 'hour': {
+            perHourCents = cents;
+            perMonthCents = cents * HOURS_PER_MONTH;
+            break;
+        }
+        case 'month': {
+            perMonthCents = cents;
+            perHourCents = cents / HOURS_PER_MONTH;
+            break;
+        }
+        default: {
+            // Unknown billing unit — leave per-month / per-hour undefined
+            // so callers can omit those labels instead of rendering
+            // fabricated numbers.
+            perMonthCents = undefined;
+            perHourCents = undefined;
+        }
+    }
+    return {
+        cents,
+        contract: Boolean(price.contract),
+        metered: Boolean(price.metered),
+        perHourCents,
+        perMonthCents,
+        unit,
+    };
+}
+/**
+ * Format a plan's price as a human-readable suffix:
+ * `"$0.007 / hour (Max $5/month)"`. Returns an empty string when the
+ * plan has no displayable price (no `price.cents`, an unknown unit,
+ * a metered plan, or a contract-priced plan) — callers can compose
+ * their final label as `${name}${suffix ? ' - ' + suffix : ''}`
+ * without per-call defensive checks.
+ *
+ * Locale and currency default to `'en-US'` / `'USD'`. Pass options
+ * to override.
+ *
+ * @example
+ * ```ts
+ * const suffix = formatPlanPriceLabel(plan);
+ * const label = suffix ? `${plan.human_name} - ${suffix}` : plan.human_name;
+ * ```
+ */
+export function formatPlanPriceLabel(plan, options = {}) {
+    const breakdown = priceForPlan(plan);
+    if (!breakdown)
+        return '';
+    // Metered and contract-priced plans don't have a meaningful flat
+    // monthly/hourly label — the consumer should describe them
+    // differently (e.g. "metered", "contract pricing"). Returning an
+    // empty string here lets the caller fall back to the plan name.
+    if (breakdown.metered || breakdown.contract)
+        return '';
+    if (breakdown.perMonthCents === undefined || breakdown.perHourCents === undefined)
+        return '';
+    const { currency = 'USD', locale = 'en-US' } = options;
+    const formatter = new Intl.NumberFormat(locale, { currency, style: 'currency' });
+    const perHour = formatter.format(breakdown.perHourCents / 100);
+    const perMonth = formatter.format(breakdown.perMonthCents / 100);
+    return `${perHour} / hour (Max ${perMonth}/month)`;
+}

package/dist/resources/platform/add-on/resolve.d.ts

@@ -0,0 +1,43 @@
+import type { ResourceCtx } from '../../../core/extend-resource.js';
+import type { PlatformClient } from '../../../services/platform.js';
+import type { AddOnOptions, ResolveAddonOptions, ResolvedAddOn } from './types.js';
+/**
+ * Resolve a Platform add-on by identity.
+ *
+ * The add-on identity may be:
+ *   - a UUID (`d5e3f2a4-...`)
+ *   - a globally-unique name (`postgres-curved-12345`)
+ *   - a namespaced credential reference (`postgres-curved-12345::SECONDARY`)
+ *
+ * When `appIdentity` is provided, the resolve is scoped to that app first
+ * and falls back to a global resolve if the platform returns 404 add_on.
+ * Namespaced identities (containing `::`) skip the app-scoped lookup
+ * because they are globally unique.
+ *
+ * `addonService` (e.g. `heroku-postgresql`) is filtered client-side after
+ * the resolve. The platform's server-side `addon_service` filter excludes
+ * alpha add-ons, so we don't pass it through.
+ *
+ * Errors:
+ *   - throws `AddonNotFoundError` if no match is found
+ *   - throws `AddonAmbiguousError` if multiple matches remain after filtering
+ *
+ * For attachment-based resolution (e.g. `DATABASE_URL` on a particular
+ * app), use `resolveAddonByAttachment` instead.
+ */
+export declare function resolveAddon(ctx: Pick<ResourceCtx, 'platform'>, addonIdentity: string, options?: ResolveAddonOptions): Promise<ResolvedAddOn>;
+/**
+ * Resolve a Platform add-on via one of its attachments on a given app.
+ *
+ * Use this when you have an attachment name (e.g. `DATABASE_URL`,
+ * `HEROKU_POSTGRESQL_GREEN`) on a known app, rather than an add-on
+ * identity. Calls `addOnAttachment.resolution` and returns the add-on
+ * the matched attachment points to.
+ *
+ * For resolving by add-on identity, use `resolveAddon`.
+ */
+export declare function resolveAddonByAttachment(ctx: Pick<ResourceCtx, 'platform'>, appIdentity: string, attachmentName: string, options?: AddOnOptions): Promise<ResolvedAddOn>;
+export declare function resolveAddonInternal(platform: PlatformClient, addonIdentity: string, options?: {
+    addonService?: string;
+    appIdentity?: string;
+}): Promise<ResolvedAddOn>;

package/dist/resources/platform/add-on/resolve.js

@@ -0,0 +1,103 @@
+import { NotFoundError } from '@heroku/heroku-fetch';
+import { debug } from './debug.js';
+import { AddonAmbiguousError, AddonNotFoundError } from './errors.js';
+/**
+ * Resolve a Platform add-on by identity.
+ *
+ * The add-on identity may be:
+ *   - a UUID (`d5e3f2a4-...`)
+ *   - a globally-unique name (`postgres-curved-12345`)
+ *   - a namespaced credential reference (`postgres-curved-12345::SECONDARY`)
+ *
+ * When `appIdentity` is provided, the resolve is scoped to that app first
+ * and falls back to a global resolve if the platform returns 404 add_on.
+ * Namespaced identities (containing `::`) skip the app-scoped lookup
+ * because they are globally unique.
+ *
+ * `addonService` (e.g. `heroku-postgresql`) is filtered client-side after
+ * the resolve. The platform's server-side `addon_service` filter excludes
+ * alpha add-ons, so we don't pass it through.
+ *
+ * Errors:
+ *   - throws `AddonNotFoundError` if no match is found
+ *   - throws `AddonAmbiguousError` if multiple matches remain after filtering
+ *
+ * For attachment-based resolution (e.g. `DATABASE_URL` on a particular
+ * app), use `resolveAddonByAttachment` instead.
+ */
+export async function resolveAddon(ctx, addonIdentity, options = {}) {
+    options.signal?.throwIfAborted();
+    return resolveAddonInternal(ctx.platform, addonIdentity, options);
+}
+/**
+ * Resolve a Platform add-on via one of its attachments on a given app.
+ *
+ * Use this when you have an attachment name (e.g. `DATABASE_URL`,
+ * `HEROKU_POSTGRESQL_GREEN`) on a known app, rather than an add-on
+ * identity. Calls `addOnAttachment.resolution` and returns the add-on
+ * the matched attachment points to.
+ *
+ * For resolving by add-on identity, use `resolveAddon`.
+ */
+export async function resolveAddonByAttachment(ctx, appIdentity, attachmentName, options = {}) {
+    options.signal?.throwIfAborted();
+    debug('resolveByAttachment app=%s attachment=%s', appIdentity, attachmentName);
+    const matches = await ctx.platform.addOnAttachment.resolution({
+        // eslint-disable-next-line camelcase
+        addon_attachment: attachmentName,
+        app: appIdentity,
+    });
+    const attachment = matches[0];
+    const addon = attachment?.addon;
+    if (!addon?.id || !addon.app?.id) {
+        debug('resolveByAttachment matches=%d (no usable add-on returned)', matches.length);
+        throw new AddonNotFoundError();
+    }
+    debug('resolveByAttachment resolved addon=%s app=%s', addon.id, addon.app.id);
+    return addon;
+}
+export async function resolveAddonInternal(platform, addonIdentity, options = {}) {
+    const { addonService, appIdentity } = options;
+    const resolveBy = async (app) => {
+        const body = app ? { addon: addonIdentity, app } : { addon: addonIdentity };
+        debug('resolve addon=%s app=%s service=%s', addonIdentity, app ?? '<global>', addonService ?? '<any>');
+        const matches = await platform.addOn.resolution(body);
+        const filtered = addonService
+            ? matches.filter(addon => addon.addon_service?.name === addonService)
+            : matches;
+        debug('resolve matches=%d filtered=%d (service=%s)', matches.length, filtered.length, addonService ?? '<any>');
+        const resolvedAddon = singularize(filtered);
+        debug('resolve resolved addon=%s app=%s', resolvedAddon.id, resolvedAddon.app.id);
+        return resolvedAddon;
+    };
+    if (!appIdentity || addonIdentity.includes('::')) {
+        debug('resolve scope=global reason=%s', appIdentity ? 'namespaced-identity' : 'no-app');
+        return resolveBy();
+    }
+    try {
+        return await resolveBy(appIdentity);
+    }
+    catch (error) {
+        if (isAddOnNotFound(error)) {
+            debug('resolve app-scope 404 add_on, falling back to global addon=%s', addonIdentity);
+            return resolveBy();
+        }
+        throw error;
+    }
+}
+function isAddOnNotFound(error) {
+    return error instanceof NotFoundError && error.resource === 'add_on';
+}
+function singularize(matches) {
+    if (matches.length === 0) {
+        throw new AddonNotFoundError();
+    }
+    if (matches.length > 1) {
+        throw new AddonAmbiguousError(matches);
+    }
+    const match = matches[0];
+    if (!match.id || !match.app?.id) {
+        throw new Error(`Resolved add-on is missing required fields (id=${match.id}, app.id=${match.app?.id})`);
+    }
+    return match;
+}

package/dist/resources/platform/add-on/types.d.ts

@@ -0,0 +1,49 @@
+import type { AddOn, AddOnAttachment } from '@heroku/types/3.sdk';
+export type AddOnOptions = {
+    signal?: AbortSignal;
+};
+export type ResolveAddonOptions = AddOnOptions & {
+    addonService?: string;
+    appIdentity?: string;
+};
+/**
+ * An add-on whose `app.id` and `id` are guaranteed non-null. This is what
+ * the Platform's resolver returns for a successful match, but the schema
+ * types both as optional. `singularize` enforces it at runtime so callers
+ * can rely on the narrower type.
+ */
+export type ResolvedAddOn = AddOn & {
+    app: AddOn['app'] & {
+        id: string;
+    };
+    id: string;
+};
+export type DescribedAddOn = ResolvedAddOn & {
+    attachments: AddOnAttachment[];
+};
+export type UpgradeAddOnOptions = ResolveAddonOptions & {
+    onResolved?: (addon: ResolvedAddOn) => Promise<void> | void;
+};
+export type CreateAndWaitOptions = {
+    /**
+     * Fires once after the initial create returns and the add-on is
+     * still provisioning, before the first poll. Receives the create
+     * response. Useful for surfacing two-phase UX: e.g. "Creating
+     * <plan>... <price>" followed by "Waiting for <addonName>...".
+     *
+     * Only invoked when `wait: true` and the create response state is
+     * `provisioning`.
+     */
+    onProvisioning?: (addon: AddOn) => Promise<void> | void;
+    /**
+     * If true, poll until the add-on leaves the `provisioning` state. If
+     * the final state is anything other than `provisioned`/`provisioning`
+     * (e.g. `deprovisioned`), throws `AddonProvisioningFailedError`.
+     *
+     * If false (the default), returns immediately after the create call —
+     * even if the add-on is still provisioning.
+     */
+    wait?: boolean;
+    /** Polling interval in milliseconds. Defaults to 5000. */
+    waitIntervalMs?: number;
+} & AddOnOptions;

package/dist/resources/platform/add-on/types.js

@@ -0,0 +1 @@
+export {};

package/dist/resources/platform/add-on/upgrade.d.ts

@@ -0,0 +1,21 @@
+import type { AddOn } from '@heroku/types/3.sdk';
+import type { ResourceCtx } from '../../../core/extend-resource.js';
+import type { UpgradeAddOnOptions } from './types.js';
+/**
+ * Change the plan of an add-on.
+ *
+ * Resolves the add-on first so the caller can pass any identifier
+ * (UUID, globally unique name, or namespaced `service::name`). When
+ * `appIdentity` is provided, the resolve is scoped to that app and
+ * falls back to a global resolve if the platform returns 404 add_on.
+ *
+ * If `plan` is unqualified (no `:`), it's prefixed with the resolved
+ * add-on's `addon_service.name` — so callers can pass `hobby` rather
+ * than `heroku-redis:hobby` if they don't already know the service.
+ *
+ * `options.onResolved` fires after the resolve and before the update,
+ * receiving the resolved add-on. Useful for surfacing pre-update
+ * state (the add-on's current plan, app, etc.) without an extra
+ * round-trip.
+ */
+export declare function upgrade(ctx: Pick<ResourceCtx, 'platform'>, addonIdentity: string, plan: string, options?: UpgradeAddOnOptions): Promise<AddOn>;

package/dist/resources/platform/add-on/upgrade.js

@@ -0,0 +1,36 @@
+import { debug } from './debug.js';
+import { resolveAddonInternal } from './resolve.js';
+/**
+ * Change the plan of an add-on.
+ *
+ * Resolves the add-on first so the caller can pass any identifier
+ * (UUID, globally unique name, or namespaced `service::name`). When
+ * `appIdentity` is provided, the resolve is scoped to that app and
+ * falls back to a global resolve if the platform returns 404 add_on.
+ *
+ * If `plan` is unqualified (no `:`), it's prefixed with the resolved
+ * add-on's `addon_service.name` — so callers can pass `hobby` rather
+ * than `heroku-redis:hobby` if they don't already know the service.
+ *
+ * `options.onResolved` fires after the resolve and before the update,
+ * receiving the resolved add-on. Useful for surfacing pre-update
+ * state (the add-on's current plan, app, etc.) without an extra
+ * round-trip.
+ */
+export async function upgrade(ctx, addonIdentity, plan, options = {}) {
+    options.signal?.throwIfAborted();
+    const addon = await resolveAddonInternal(ctx.platform, addonIdentity, {
+        addonService: options.addonService,
+        appIdentity: options.appIdentity,
+    });
+    await options.onResolved?.(addon);
+    options.signal?.throwIfAborted();
+    const qualifiedPlan = plan.includes(':')
+        ? plan
+        : `${addon.addon_service?.name}:${plan}`;
+    if (qualifiedPlan !== plan) {
+        debug('upgrade plan qualified plan=%s qualified=%s', plan, qualifiedPlan);
+    }
+    debug('upgrade addon=%s app=%s plan=%s', addon.id, addon.app.id, qualifiedPlan);
+    return ctx.platform.addOn.update(addon.app.id, addon.id, { plan: qualifiedPlan });
+}

package/dist/resources/platform/add-on.d.ts

@@ -0,0 +1,211 @@
+import type { AddOn, AddOnAttachment, AddOnCreateOpts, Plan } from '@heroku/types/3.sdk';
+import type { ResourceCtx } from '../../core/extend-resource.js';
+export type AddOnOptions = {
+    signal?: AbortSignal;
+};
+export type ResolveAddonOptions = AddOnOptions & {
+    addonService?: string;
+    appIdentity?: string;
+};
+/**
+ * An add-on whose `app.id` and `id` are guaranteed non-null. This is what
+ * the Platform's resolver returns for a successful match, but the schema
+ * types both as optional. `singularize` enforces it at runtime so callers
+ * can rely on the narrower type.
+ */
+export type ResolvedAddOn = AddOn & {
+    app: AddOn['app'] & {
+        id: string;
+    };
+    id: string;
+};
+export type DescribedAddOn = ResolvedAddOn & {
+    attachments: AddOnAttachment[];
+};
+export type UpgradeAddOnOptions = ResolveAddonOptions & {
+    onResolved?: (addon: ResolvedAddOn) => Promise<void> | void;
+};
+export declare class AddonNotFoundError extends Error {
+    readonly resource: string;
+    readonly id = "not_found";
+    readonly statusCode = 404;
+    constructor(resource?: string);
+    get body(): {
+        id: string;
+        message: string;
+        resource: string;
+    };
+}
+export declare class AddonAmbiguousError extends Error {
+    readonly matches: AddOn[];
+    readonly id = "multiple_matches";
+    readonly statusCode = 422;
+    constructor(matches: AddOn[]);
+    get body(): {
+        id: string;
+        message: string;
+    };
+}
+/**
+ * Thrown by `createAndWait` when the Platform returns 423
+ * `confirmation_required`. Callers that want to prompt the user should
+ * catch this, gather a confirmation value, and retry the call with
+ * `body.confirm` set.
+ */
+export declare class AddonConfirmationRequiredError extends Error {
+    readonly platformMessage: string;
+    readonly id = "confirmation_required";
+    readonly statusCode = 423;
+    constructor(platformMessage: string);
+    get body(): {
+        id: string;
+        message: string;
+    };
+}
+/**
+ * Thrown by `createAndWait` when the Platform reports the add-on
+ * settled into a non-provisioned terminal state (e.g. `deprovisioned`).
+ */
+export declare class AddonProvisioningFailedError extends Error {
+    readonly addon: AddOn;
+    readonly id = "provisioning_failed";
+    constructor(addon: AddOn);
+    get body(): {
+        id: string;
+        message: string;
+    };
+}
+/**
+ * Change the plan of an add-on.
+ *
+ * Resolves the add-on first so the caller can pass any identifier
+ * (UUID, globally unique name, or namespaced `service::name`). When
+ * `appIdentity` is provided, the resolve is scoped to that app and
+ * falls back to a global resolve if the platform returns 404 add_on.
+ *
+ * If `plan` is unqualified (no `:`), it's prefixed with the resolved
+ * add-on's `addon_service.name` — so callers can pass `hobby` rather
+ * than `heroku-redis:hobby` if they don't already know the service.
+ *
+ * `options.onResolved` fires after the resolve and before the update,
+ * receiving the resolved add-on. Useful for surfacing pre-update
+ * state (the add-on's current plan, app, etc.) without an extra
+ * round-trip.
+ */
+export declare function upgrade(ctx: Pick<ResourceCtx, 'platform'>, addonIdentity: string, plan: string, options?: UpgradeAddOnOptions): Promise<AddOn>;
+export type CreateAndWaitOptions = {
+    /**
+     * Fires once after the initial create returns and the add-on is
+     * still provisioning, before the first poll. Receives the create
+     * response. Useful for surfacing two-phase UX: e.g. "Creating
+     * <plan>... <price>" followed by "Waiting for <addonName>...".
+     *
+     * Only invoked when `wait: true` and the create response state is
+     * `provisioning`.
+     */
+    onProvisioning?: (addon: AddOn) => Promise<void> | void;
+    /**
+     * If true, poll until the add-on leaves the `provisioning` state. If
+     * the final state is anything other than `provisioned`/`provisioning`
+     * (e.g. `deprovisioned`), throws `AddonProvisioningFailedError`.
+     *
+     * If false (the default), returns immediately after the create call —
+     * even if the add-on is still provisioning.
+     */
+    wait?: boolean;
+    /** Polling interval in milliseconds. Defaults to 5000. */
+    waitIntervalMs?: number;
+} & AddOnOptions;
+/**
+ * Create an add-on and optionally wait for provisioning to complete.
+ *
+ * Wraps `addOn.create` with three pieces of orchestration:
+ *
+ *   - 423 `confirmation_required` from the platform is converted to a
+ *     typed `AddonConfirmationRequiredError`. Callers should catch
+ *     this, prompt the user for confirmation, and retry the call with
+ *     `body.confirm` set.
+ *   - When `wait: true` is set, polls `addOn.infoByApp` on a
+ *     `waitIntervalMs` cadence until the add-on's `state` is no longer
+ *     `provisioning`. Throws `AddonProvisioningFailedError` if the
+ *     terminal state is `deprovisioned`.
+ *   - `options.onProvisioning` fires once after the create response
+ *     when polling is about to begin, letting callers surface a
+ *     two-phase status display ("Created" → "Waiting").
+ *
+ * Both the create and poll calls are issued with `Accept-Expansion:
+ * addon_service,plan` so the response includes the full plan shape
+ * (price, unit, etc.). The create call additionally sets
+ * `X-Heroku-Legacy-Provider-Messages: true` to opt into
+ * provider-supplied `provision_message` text on the response — without
+ * it the platform silently omits that field.
+ */
+export declare function createAndWait(ctx: Pick<ResourceCtx, 'platform'>, appIdentity: string, body: AddOnCreateOpts, options?: CreateAndWaitOptions): Promise<AddOn>;
+/**
+ * List the plans available for an add-on service, sorted ascending by
+ * `price.cents`. Plans without a price (or with equal prices) are
+ * returned later in the list.
+ */
+export declare function listPlans(ctx: Pick<ResourceCtx, 'platform'>, serviceIdentity: string, options?: AddOnOptions): Promise<Plan[]>;
+/**
+ * Resolve, describe, and decorate an add-on for display.
+ *
+ * - Resolves the add-on by identity (optionally scoped to an app).
+ * - Loads the add-on's attachments.
+ * - Returns a copy with `plan.price` set from `billed_price` (so the
+ *   value reflects any grandfathered/contract pricing).
+ *
+ * If `appIdentity` is provided and the platform returns 404 (resource
+ * `add_on`), the resolve falls back to a global lookup. This handles
+ * the case where the add-on belongs to a different app than the one
+ * supplied.
+ *
+ * Requests the `version=3.sdk` accept variant with `addon_service,plan`
+ * expansion so the resolved add-on includes the full `Plan` shape
+ * (`price.unit`, etc.) needed to render pricing.
+ */
+export declare function describeAddon(ctx: Pick<ResourceCtx, 'platform'>, addonIdentity: string, options?: ResolveAddonOptions): Promise<DescribedAddOn>;
+/**
+ * Resolve a Platform add-on by identity.
+ *
+ * The add-on identity may be:
+ *   - a UUID (`d5e3f2a4-...`)
+ *   - a globally-unique name (`postgres-curved-12345`)
+ *   - a namespaced credential reference (`postgres-curved-12345::SECONDARY`)
+ *
+ * When `appIdentity` is provided, the resolve is scoped to that app first
+ * and falls back to a global resolve if the platform returns 404 add_on.
+ * Namespaced identities (containing `::`) skip the app-scoped lookup
+ * because they are globally unique.
+ *
+ * `addonService` (e.g. `heroku-postgresql`) is filtered client-side after
+ * the resolve. The platform's server-side `addon_service` filter excludes
+ * alpha add-ons, so we don't pass it through.
+ *
+ * Errors:
+ *   - throws `AddonNotFoundError` if no match is found
+ *   - throws `AddonAmbiguousError` if multiple matches remain after filtering
+ *
+ * For attachment-based resolution (e.g. `DATABASE_URL` on a particular
+ * app), use `resolveAddonByAttachment` instead.
+ */
+export declare function resolveAddon(ctx: Pick<ResourceCtx, 'platform'>, addonIdentity: string, options?: ResolveAddonOptions): Promise<ResolvedAddOn>;
+/**
+ * Resolve a Platform add-on via one of its attachments on a given app.
+ *
+ * Use this when you have an attachment name (e.g. `DATABASE_URL`,
+ * `HEROKU_POSTGRESQL_GREEN`) on a known app, rather than an add-on
+ * identity. Calls `addOnAttachment.resolution` and returns the add-on
+ * the matched attachment points to.
+ *
+ * For resolving by add-on identity, use `resolveAddon`.
+ */
+export declare function resolveAddonByAttachment(ctx: Pick<ResourceCtx, 'platform'>, appIdentity: string, attachmentName: string, options?: AddOnOptions): Promise<ResolvedAddOn>;
+export declare const addOnExtensions: import("../../index.js").ResourceExtension<"platform", "addOn", {
+    createAndWait: (appIdentity: string, body: AddOnCreateOpts, options?: CreateAndWaitOptions) => Promise<AddOn>;
+    describe: (addonIdentity: string, options?: ResolveAddonOptions) => Promise<DescribedAddOn>;
+    listPlans: (serviceIdentity: string, options?: AddOnOptions) => Promise<Plan[]>;
+    resolve: (addonIdentity: string, options?: ResolveAddonOptions) => Promise<ResolvedAddOn>;
+    resolveByAttachment: (appIdentity: string, attachmentName: string, options?: AddOnOptions) => Promise<ResolvedAddOn>;
+    upgrade: (addonIdentity: string, plan: string, options?: UpgradeAddOnOptions) => Promise<AddOn>;
+}>;