@heroku/sdk 0.5.7 → 0.6.1

package/README.md

@@ -1,6 +1,6 @@
 # Heroku SDK
 
-A TypeScript SDK for the [Heroku Platform API](https://devcenter.heroku.com/articles/platform-api-reference), [Heroku Data API](https://devcenter.heroku.com/articles/heroku-postgres-api-reference), and the Heroku Metrics API. It generates fully-typed clients at runtime from route definitions — no hand-written method per endpoint.
+A TypeScript SDK for the [Heroku Platform API](https://devcenter.heroku.com/articles/platform-api-reference), [Heroku Data API](https://devcenter.heroku.com/articles/heroku-postgres-api-reference), the Heroku Dashboard Backend, the Heroku Metrics API, and the Heroku Repositories API. It generates fully-typed clients at runtime from route definitions — no hand-written method per endpoint.
 
 ## Installation
 
@@ -22,31 +22,69 @@ const sdk = new HerokuSDK({ extensions: [appExtensions] })
 // Upstream route (auto-generated from the API spec)
 const apps = await sdk.platform.app.list()
 const app  = await sdk.platform.app.info('my-app')
+const favorites = await sdk.dashboardBackend.favorite.list({ type: 'app' })
 
 // Hand-written extension method (provided by appExtensions)
 await sdk.platform.app.enableMaintenance('my-app')
 ```
 
+Extensions can also coordinate multiple services. For example, resolve a
+pipeline first, then resolve its GitHub repository through Repositories API
+with the Kolkrabbi-backed repositories service as a fallback:
+
+```ts
+import { HerokuSDK } from '@heroku/sdk'
+import { reviewAppConfigExtensions } from '@heroku/sdk/extensions/platform'
+
+const sdk = new HerokuSDK({ extensions: [reviewAppConfigExtensions] })
+const pipeline = await sdk.platform.pipeline.info('my-pipeline')
+
+if (!pipeline.id) throw new Error('Pipeline response did not include an id')
+const repo = await sdk.platform.reviewAppConfig.resolveRepoName(pipeline.id)
+```
+
 You can also pass options directly:
 
 ```ts
 const sdk = new HerokuSDK({ clientOptions: { token: 'your-api-token' } })
 ```
 
+Common client options apply to every service. In particular, a common `baseUrl`
+overrides every service's default host, including Metrics and Repositories. Use
+shallow per-service overrides when only specific services should use a host or
+other client setting:
+
+```ts
+const sdk = new HerokuSDK({
+  clientOptions: { token: 'your-api-token' },
+  clientOptionsByService: {
+    platform: { baseUrl: 'https://api.heroku.com' },
+    repositoriesApi: { baseUrl: 'https://api.heroku.com' },
+  },
+})
+```
+
 ### Per-service clients
 
 If you only need one service (and want the smallest possible bundle), import the factory directly. These return the same typed client the SDK class wraps internally.
 
 ```ts
-import { createPlatformClient } from '@heroku/sdk/platform'
-import { createDataClient }     from '@heroku/sdk/data'
-import { createMetricsClient }  from '@heroku/sdk/metrics'
-
-const platform = createPlatformClient()
-const data     = createDataClient()
-const metrics  = createMetricsClient()
+import { createPlatformClient }     from '@heroku/sdk/platform'
+import { createDataClient }         from '@heroku/sdk/data'
+import { createDashboardBackendClient } from '@heroku/sdk/dashboard-backend'
+import { createMetricsClient }      from '@heroku/sdk/metrics'
+import { createRepositoriesClient } from '@heroku/sdk/repositories'
+import { createRepositoriesApiClient } from '@heroku/sdk/repositories-api'
+
+const platform     = createPlatformClient()
+const data         = createDataClient()
+const dashboardBackend = createDashboardBackendClient()
+const metrics      = createMetricsClient()
+const repositories = createRepositoriesClient()
+const repositoriesApi = createRepositoriesApiClient()
 
 const apps = await platform.app.list()
+const favorites = await dashboardBackend.favorite.list({ type: 'app' })
 ```
 
 ### Imports
@@ -56,7 +94,10 @@ const apps = await platform.app.list()
 | `HerokuSDK`, `extendResource`, types     | `@heroku/sdk`                     |
 | `createPlatformClient`, `PlatformClient` | `@heroku/sdk/platform`            |
 | `createDataClient`, `DataClient`         | `@heroku/sdk/data`                |
+| `createDashboardBackendClient`, `DashboardBackendClient` | `@heroku/sdk/dashboard-backend` |
 | `createMetricsClient`, `MetricsClient`   | `@heroku/sdk/metrics`             |
+| `createRepositoriesClient`, `RepositoriesClient` | `@heroku/sdk/repositories` |
+| `createRepositoriesApiClient`, `RepositoriesApiClient` | `@heroku/sdk/repositories-api` |
 | `appExtensions`, `dynoExtensions`, …     | `@heroku/sdk/extensions/platform` |
 | `databaseExtensions`, …                  | `@heroku/sdk/extensions/data`     |
 

package/dist/core/extend-resource.d.ts

@@ -1,11 +1,20 @@
+import type { DashboardBackendClient } from '../services/dashboard-backend.js';
 import type { DataClient } from '../services/data.js';
 import type { MetricsClient } from '../services/metrics.js';
 import type { PlatformClient } from '../services/platform.js';
-export type ServiceName = 'data' | 'metrics' | 'platform';
-export type ResourceCtx = {
+import type { RepositoriesApiClient } from '../services/repositories-api.js';
+import type { RepositoriesClient } from '../services/repositories.js';
+export type ServiceName = 'dashboardBackend' | 'data' | 'metrics' | 'platform' | 'repositories' | 'repositoriesApi';
+type BaseResourceCtx = {
+    dashboardBackend: DashboardBackendClient;
     data: DataClient;
     metrics: MetricsClient;
     platform: PlatformClient;
+    repositories: RepositoriesClient;
+};
+export type ResourceCtx = BaseResourceCtx & {
+    /** Available to SDK-provided extensions; optional for compatibility with existing extension contexts. */
+    repositoriesApi?: RepositoriesApiClient;
 };
 export type ResourceMethods = Record<string, (...args: any[]) => any>;
 export type ResourceExtension<S extends ServiceName = ServiceName, R extends string = string, M extends ResourceMethods = ResourceMethods> = {

package/dist/core/heroku-sdk.d.ts

@@ -1,16 +1,28 @@
 import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
+import type { DashboardBackendClient } from '../services/dashboard-backend.js';
 import type { DataClient } from '../services/data.js';
 import type { MetricsClient } from '../services/metrics.js';
 import type { PlatformClient } from '../services/platform.js';
-import type { ApplyExtensions, ExtensionsFor, ResourceExtension } from './extend-resource.js';
+import type { RepositoriesApiClient } from '../services/repositories-api.js';
+import type { RepositoriesClient } from '../services/repositories.js';
+import type { ApplyExtensions, ExtensionsFor, ResourceExtension, ServiceName } from './extend-resource.js';
+type ServiceClientOptions = Omit<HerokuApiClientOptions, 'service'> & {
+    service?: never;
+};
 export type HerokuSDKOptions<Exts extends readonly ResourceExtension[]> = {
     clientOptions?: HerokuApiClientOptions;
+    /** Shallow per-service overrides applied after common clientOptions. */
+    clientOptionsByService?: Partial<Record<ServiceName, ServiceClientOptions>>;
     extensions?: Exts;
 };
 export declare class HerokuSDK<const Exts extends readonly ResourceExtension[] = readonly ResourceExtension[]> {
     #private;
     constructor(options?: HerokuSDKOptions<Exts>);
+    get dashboardBackend(): ApplyExtensions<DashboardBackendClient, ExtensionsFor<Exts, 'dashboardBackend'>>;
     get data(): ApplyExtensions<DataClient, ExtensionsFor<Exts, 'data'>>;
     get metrics(): ApplyExtensions<MetricsClient, ExtensionsFor<Exts, 'metrics'>>;
     get platform(): ApplyExtensions<PlatformClient, ExtensionsFor<Exts, 'platform'>>;
+    get repositories(): ApplyExtensions<RepositoriesClient, ExtensionsFor<Exts, 'repositories'>>;
+    get repositoriesApi(): ApplyExtensions<RepositoriesApiClient, ExtensionsFor<Exts, 'repositoriesApi'>>;
 }
+export {};

package/dist/core/heroku-sdk.js

@@ -1,6 +1,9 @@
+import { createDashboardBackendClient } from '../services/dashboard-backend.js';
 import { createDataClient } from '../services/data.js';
 import { createMetricsClient } from '../services/metrics.js';
 import { createPlatformClient } from '../services/platform.js';
+import { createRepositoriesApiClient } from '../services/repositories-api.js';
+import { createRepositoriesClient } from '../services/repositories.js';
 import { mergeExtensions } from './extensions-proxy.js';
 function partitionByService(extensions) {
     const map = new Map();
@@ -13,18 +16,30 @@ function partitionByService(extensions) {
 }
 export class HerokuSDK {
     #clientOptions;
+    #clientOptionsByService;
     #ctx;
+    #dashboardBackend;
     #data;
     #extensionsByService;
     #metrics;
     #platform;
+    #rawDashboardBackend;
     #rawData;
     #rawMetrics;
     #rawPlatform;
+    #rawRepositories;
+    #rawRepositoriesApi;
+    #repositories;
+    #repositoriesApi;
     constructor(options = {}) {
         this.#clientOptions = options.clientOptions ?? {};
+        this.#clientOptionsByService = options.clientOptionsByService ?? {};
         this.#extensionsByService = partitionByService(options.extensions ?? []);
     }
+    get dashboardBackend() {
+        this.#dashboardBackend ??= mergeExtensions(this.#getRawDashboardBackend(), this.#extensionsByService.get('dashboardBackend') ?? [], this.#getCtx());
+        return this.#dashboardBackend;
+    }
     get data() {
         this.#data ??= mergeExtensions(this.#getRawData(), this.#extensionsByService.get('data') ?? [], this.#getCtx());
         return this.#data;
@@ -37,8 +52,29 @@ export class HerokuSDK {
         this.#platform ??= mergeExtensions(this.#getRawPlatform(), this.#extensionsByService.get('platform') ?? [], this.#getCtx());
         return this.#platform;
     }
+    get repositories() {
+        this.#repositories ??= mergeExtensions(this.#getRawRepositories(), this.#extensionsByService.get('repositories') ?? [], this.#getCtx());
+        return this.#repositories;
+    }
+    get repositoriesApi() {
+        this.#repositoriesApi ??= mergeExtensions(this.#getRawRepositoriesApi(), this.#extensionsByService.get('repositoriesApi') ?? [], this.#getCtx());
+        return this.#repositoriesApi;
+    }
+    #getClientOptions(service) {
+        const serviceOverride = this.#clientOptionsByService[service];
+        const serviceOptions = { ...serviceOverride };
+        delete serviceOptions.service;
+        return {
+            ...this.#clientOptions,
+            ...serviceOptions,
+        };
+    }
     #getCtx() {
         this.#ctx ??= Object.defineProperties({}, {
+            dashboardBackend: {
+                enumerable: true,
+                get: () => this.#getRawDashboardBackend(),
+            },
             data: {
                 enumerable: true,
                 get: () => this.#getRawData(),
@@ -51,19 +87,39 @@ export class HerokuSDK {
                 enumerable: true,
                 get: () => this.#getRawPlatform(),
             },
+            repositories: {
+                enumerable: true,
+                get: () => this.#getRawRepositories(),
+            },
+            repositoriesApi: {
+                enumerable: true,
+                get: () => this.#getRawRepositoriesApi(),
+            },
         });
         return this.#ctx;
     }
+    #getRawDashboardBackend() {
+        this.#rawDashboardBackend ??= createDashboardBackendClient(this.#getClientOptions('dashboardBackend'));
+        return this.#rawDashboardBackend;
+    }
     #getRawData() {
-        this.#rawData ??= createDataClient(this.#clientOptions);
+        this.#rawData ??= createDataClient(this.#getClientOptions('data'));
         return this.#rawData;
     }
     #getRawMetrics() {
-        this.#rawMetrics ??= createMetricsClient(this.#clientOptions);
+        this.#rawMetrics ??= createMetricsClient(this.#getClientOptions('metrics'));
         return this.#rawMetrics;
     }
     #getRawPlatform() {
-        this.#rawPlatform ??= createPlatformClient(this.#clientOptions);
+        this.#rawPlatform ??= createPlatformClient(this.#getClientOptions('platform'));
         return this.#rawPlatform;
     }
+    #getRawRepositories() {
+        this.#rawRepositories ??= createRepositoriesClient(this.#getClientOptions('repositories'));
+        return this.#rawRepositories;
+    }
+    #getRawRepositoriesApi() {
+        this.#rawRepositoriesApi ??= createRepositoriesApiClient(this.#getClientOptions('repositoriesApi'));
+        return this.#rawRepositoriesApi;
+    }
 }

package/dist/resources/extensions/platform.d.ts

@@ -1,5 +1,5 @@
 export { addOnExtensions } from '../platform/add-on/index.js';
-export { appExtensions, type AppInfo, type PipelineCouplingDetail } from '../platform/app/index.js';
+export { appExtensions, type AppInfo, type DiffAppsOptions, type DiffRow, type PipelineCouplingDetail, } from '../platform/app/index.js';
 export { containerExtensions, type DockerReleasesBatchUpdateOpts, NotAContainerAppError, type ReleaseDockerImagesResult, type RemoveProcessTypesOpts, } from '../platform/container/index.js';
 export { type CreateAndWaitOptions, domainExtensions, type DomainOptions, type WaitForReadyOptions, } from '../platform/domain/index.js';
 export { dynoExtensions, DynoNotReadyError, type DynoState, runDyno, type RunDynoOptions, waitForInfo, type WaitForInfoOptions, } from '../platform/dyno/index.js';
@@ -7,7 +7,10 @@ export { type AttachmentAttachedEvent, type AttachmentDetachedEvent, type Attach
 export { pipelineCouplingExtensions } from '../platform/pipeline/coupling.js';
 export { pipelineExtensions } from '../platform/pipeline/index.js';
 export { pipelinePromotionExtensions } from '../platform/pipeline/promotion.js';
+export { type ResolveRepoNameOptions, reviewAppConfigExtensions } from '../platform/review-app-config/index.js';
 export { privateToShield, shieldToPrivate } from '../platform/shield.js';
 export { createAndAssociate, type CreateAndAssociateOptions, sniEndpointExtensions } from '../platform/sni-endpoint/index.js';
+export { spaceExtensions, SpaceNotAllocatedError, SpaceNotReadyError, type SpaceOptions, type SpaceWithNat, waitForAllocated, type WaitForAllocatedOptions, } from '../platform/space/index.js';
 export { telemetryDrainExtensions, type TelemetryDrainOptions, type TelemetryDrainTarget } from '../platform/telemetry-drain/index.js';
 export { testRunExtensions, TestRunNotReadyError, type TestRunStatus, waitForState, type WaitForStateOptions, } from '../platform/test-run/index.js';
+export { vpnConnectionExtensions, VpnConnectionFailedError, VpnConnectionNotReadyError, type VpnConnectionOptions, waitForActive, type WaitForActiveOptions, } from '../platform/vpn-connection/index.js';

package/dist/resources/extensions/platform.js

@@ -1,5 +1,5 @@
 export { addOnExtensions } from '../platform/add-on/index.js';
-export { appExtensions } from '../platform/app/index.js';
+export { appExtensions, } from '../platform/app/index.js';
 export { containerExtensions, NotAContainerAppError, } from '../platform/container/index.js';
 export { domainExtensions, } from '../platform/domain/index.js';
 export { dynoExtensions, DynoNotReadyError, runDyno, waitForInfo, } from '../platform/dyno/index.js';
@@ -7,7 +7,10 @@ export { logSessionExtensions, parseHerokuLogLine, } from '../platform/log-sessi
 export { pipelineCouplingExtensions } from '../platform/pipeline/coupling.js';
 export { pipelineExtensions } from '../platform/pipeline/index.js';
 export { pipelinePromotionExtensions } from '../platform/pipeline/promotion.js';
+export { reviewAppConfigExtensions } from '../platform/review-app-config/index.js';
 export { privateToShield, shieldToPrivate } from '../platform/shield.js';
 export { createAndAssociate, sniEndpointExtensions } from '../platform/sni-endpoint/index.js';
+export { spaceExtensions, SpaceNotAllocatedError, SpaceNotReadyError, waitForAllocated, } from '../platform/space/index.js';
 export { telemetryDrainExtensions } from '../platform/telemetry-drain/index.js';
 export { testRunExtensions, TestRunNotReadyError, waitForState, } from '../platform/test-run/index.js';
+export { vpnConnectionExtensions, VpnConnectionFailedError, VpnConnectionNotReadyError, waitForActive, } from '../platform/vpn-connection/index.js';

package/dist/resources/platform/app/diff.d.ts

@@ -0,0 +1,20 @@
+import type { ResourceCtx } from '../../../core/extend-resource.js';
+export type DiffAppsOptions = {
+    signal?: AbortSignal;
+};
+export interface DiffRow {
+    app1: string | undefined;
+    app2: string | undefined;
+    prop: string;
+}
+/**
+ * Composite diff of two apps: compares slug checksum, config vars, stack,
+ * buildpacks, add-ons, and features, returning one `DiffRow` per differing
+ * property.
+ *
+ * Faithful port of the Heroku CLI's `apps:diff`: `diffFiles` runs first (so a
+ * missing app surfaces the `App not found: <app>` error before the rest), then
+ * the remaining five diffs run in parallel and their rows are concatenated in
+ * the CLI's order. Rendering (truncation, table output) stays with the caller.
+ */
+export declare function diffApps(ctx: Pick<ResourceCtx, 'platform'>, app1: string, app2: string, options?: DiffAppsOptions): Promise<DiffRow[]>;

package/dist/resources/platform/app/diff.js

@@ -0,0 +1,110 @@
+import { NotFoundError } from '@heroku/heroku-fetch';
+async function checksum(platform, app) {
+    try {
+        const releases = await platform.withHeaders({ Range: 'version ..; max=1, order=desc' }).release.list(app);
+        if (releases?.[0]?.slug) {
+            const slugId = releases[0].slug.id;
+            const slug = await platform.slug.info(app, slugId);
+            return slug?.checksum ?? null;
+        }
+        return null;
+    }
+    catch (error) {
+        if (isNotFound(error)) {
+            throw new Error(`App not found: ${app}`, { cause: error });
+        }
+        throw error;
+    }
+}
+function isNotFound(error) {
+    return error instanceof NotFoundError;
+}
+async function diffFiles(platform, app1, app2) {
+    const sums = await Promise.all([checksum(platform, app1), checksum(platform, app2)]);
+    return sums[0] === sums[1] ? [] : [{ app1: sums[0] ?? undefined, app2: sums[1] ?? undefined, prop: 'slug (checksum)' }];
+}
+async function diffEnv(platform, app1, app2) {
+    const [vars1, vars2] = await Promise.all([
+        platform.configVar.infoForApp(app1),
+        platform.configVar.infoForApp(app2),
+    ]);
+    const cfg1 = vars1 ?? {};
+    const cfg2 = vars2 ?? {};
+    const keys = new Set([...Object.keys(cfg1), ...Object.keys(cfg2)]);
+    return [...keys]
+        .filter(k => cfg1[k] !== cfg2[k])
+        .map(k => ({ app1: cfg1[k], app2: cfg2[k], prop: `config (${k})` }));
+}
+async function diffStack(platform, app1, app2) {
+    const [res1, res2] = await Promise.all([
+        platform.app.info(app1),
+        platform.app.info(app2),
+    ]);
+    const a = res1?.stack?.name;
+    const b = res2?.stack?.name;
+    return a === b ? [] : [{ app1: a, app2: b, prop: 'stack' }];
+}
+async function diffBuildpacks(platform, app1, app2) {
+    const [res1, res2] = await Promise.all([
+        platform.buildpackInstallation.list(app1),
+        platform.buildpackInstallation.list(app2),
+    ]);
+    const bps1 = res1 ?? [];
+    const bps2 = res2 ?? [];
+    const urls1 = bps1.map(obj => obj.buildpack?.url ?? '');
+    const urls2 = bps2.map(obj => obj.buildpack?.url ?? '');
+    const longest = urls1.length >= urls2.length ? urls1 : urls2;
+    const pairs = longest.map((_, k) => ({
+        app1: urls1[k],
+        app2: urls2[k],
+        prop: `buildpack (${k})`,
+    }));
+    return pairs.filter(pair => pair.app1 !== pair.app2);
+}
+async function diffAddons(platform, app1, app2) {
+    const [addons1, addons2] = await Promise.all([
+        platform.addOn.listByApp(app1),
+        platform.addOn.listByApp(app2),
+    ]);
+    const names1 = new Set((addons1 ?? []).map(addon => addon.addon_service?.name ?? '').filter(Boolean));
+    const names2 = new Set((addons2 ?? []).map(addon => addon.addon_service?.name ?? '').filter(Boolean));
+    const only1 = [...names1].filter(name => !names2.has(name)).map(name => ({ app1: 'true', app2: 'false', prop: `add-on (${name})` }));
+    const only2 = [...names2].filter(name => !names1.has(name)).map(name => ({ app1: 'false', app2: 'true', prop: `add-on (${name})` }));
+    return [...only1, ...only2];
+}
+async function diffFeatures(platform, app1, app2) {
+    const [features1, features2] = await Promise.all([
+        platform.appFeature.list(app1),
+        platform.appFeature.list(app2),
+    ]);
+    const names1 = new Set((features1 ?? []).map(f => (f.enabled ? f.name : null)).filter(Boolean));
+    const names2 = new Set((features2 ?? []).map(f => (f.enabled ? f.name : null)).filter(Boolean));
+    const only1 = [...names1].filter(name => !names2.has(name)).map(name => ({ app1: 'enabled', app2: 'disabled', prop: `feature (${name})` }));
+    const only2 = [...names2].filter(name => !names1.has(name)).map(name => ({ app1: 'disabled', app2: 'enabled', prop: `feature (${name})` }));
+    return [...only1, ...only2];
+}
+/**
+ * Composite diff of two apps: compares slug checksum, config vars, stack,
+ * buildpacks, add-ons, and features, returning one `DiffRow` per differing
+ * property.
+ *
+ * Faithful port of the Heroku CLI's `apps:diff`: `diffFiles` runs first (so a
+ * missing app surfaces the `App not found: <app>` error before the rest), then
+ * the remaining five diffs run in parallel and their rows are concatenated in
+ * the CLI's order. Rendering (truncation, table output) stays with the caller.
+ */
+export async function diffApps(ctx, app1, app2, options = {}) {
+    options.signal?.throwIfAborted();
+    const platform = options.signal
+        ? ctx.platform.withOptions({ signal: options.signal })
+        : ctx.platform;
+    const files = await diffFiles(platform, app1, app2);
+    const [env, stack, bp, addons, features] = await Promise.all([
+        diffEnv(platform, app1, app2),
+        diffStack(platform, app1, app2),
+        diffBuildpacks(platform, app1, app2),
+        diffAddons(platform, app1, app2),
+        diffFeatures(platform, app1, app2),
+    ]);
+    return [...files, ...env, ...stack, ...bp, ...addons, ...features];
+}

package/dist/resources/platform/app/index.d.ts

@@ -1,10 +1,12 @@
 import type { App } from '@heroku/types/3.sdk';
 import type { ResourceCtx } from '../../../core/extend-resource.js';
 import type { CreateAndSetupInput, CreateAndSetupOptions } from './create-and-setup.js';
+import type { DiffAppsOptions } from './diff.js';
 import type { DescribeAppOptions } from './info.js';
 import type { TransferOptions } from './transfer.js';
 import type { WaitForACMCertificatesOptions } from './wait-for-acm-certificates.js';
 export { createAndSetup, type CreateAndSetupInput, type CreateAndSetupOptions, type SetupStep, } from './create-and-setup.js';
+export { diffApps, type DiffAppsOptions, type DiffRow } from './diff.js';
 export { type AppInfo, describeApp, type DescribeAppOptions, type PipelineCouplingDetail, } from './info.js';
 export { transferApp, type TransferOptions } from './transfer.js';
 export { waitForACMCertificates, type WaitForACMCertificatesOptions } from './wait-for-acm-certificates.js';
@@ -57,6 +59,7 @@ export declare function getProcessTier(ctx: {
 export declare const appExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "app", {
     createAndSetup: (input: CreateAndSetupInput, options?: CreateAndSetupOptions) => Promise<App>;
     describe: (appIdentity: string, options?: DescribeAppOptions) => Promise<import("./info.js").AppInfo>;
+    diff: (app1: string, app2: string, options?: DiffAppsOptions) => Promise<import("./diff.js").DiffRow[]>;
     disableMaintenance: (appIdentity: string, options?: AppMaintenanceOptions) => Promise<App>;
     enableMaintenance: (appIdentity: string, options?: AppMaintenanceOptions) => Promise<App>;
     getGeneration: (appIdentity: string, options?: GetGenerationOptions) => Promise<GenerationKind | undefined>;

package/dist/resources/platform/app/index.js

@@ -1,9 +1,11 @@
 import { extendResource } from '../../../core/extend-resource.js';
 import { createAndSetup } from './create-and-setup.js';
+import { diffApps } from './diff.js';
 import { describeApp } from './info.js';
 import { transferApp } from './transfer.js';
 import { waitForACMCertificates } from './wait-for-acm-certificates.js';
 export { createAndSetup, } from './create-and-setup.js';
+export { diffApps } from './diff.js';
 export { describeApp, } from './info.js';
 export { transferApp } from './transfer.js';
 export { waitForACMCertificates } from './wait-for-acm-certificates.js';
@@ -52,6 +54,7 @@ export async function getProcessTier(ctx, appIdentity, options = {}) {
 export const appExtensions = extendResource('platform', 'app', ctx => ({
     createAndSetup: (input, options) => createAndSetup(ctx, input, options),
     describe: (appIdentity, options) => describeApp(ctx, appIdentity, options),
+    diff: (app1, app2, options) => diffApps(ctx, app1, app2, options),
     disableMaintenance: (appIdentity, options) => disableMaintenance(ctx, appIdentity, options),
     enableMaintenance: (appIdentity, options) => enableMaintenance(ctx, appIdentity, options),
     getGeneration: (appIdentity, options) => getGeneration(ctx, appIdentity, options),

package/dist/resources/platform/container/ensure-container-stack.d.ts

@@ -2,14 +2,9 @@ import type { App } from '@heroku/types/3.sdk';
 import type { ResourceCtx } from '../../../core/extend-resource.js';
 import type { ContainerOptions } from './index.js';
 export declare class NotAContainerAppError extends Error {
-    readonly app: Pick<App, 'build_stack' | 'id' | 'name' | 'stack'>;
+    readonly app: App;
     readonly id = "not_a_container_app";
-    constructor(app: Pick<App, 'build_stack' | 'id' | 'name' | 'stack'>);
-    get body(): {
-        app: Pick<App, "stack" | "id" | "name" | "build_stack">;
-        id: string;
-        message: string;
-    };
+    constructor(app: App);
 }
 /**
  * Ensure that the given app is a container app.

package/dist/resources/platform/container/ensure-container-stack.js

@@ -6,9 +6,6 @@ export class NotAContainerAppError extends Error {
         this.app = app;
         this.name = 'NotAContainerAppError';
     }
-    get body() {
-        return { app: this.app, id: this.id, message: this.message };
-    }
 }
 /**
  * Ensure that the given app is a container app.
@@ -21,12 +18,6 @@ export async function ensureContainerStack(ctx, appIdentity, options = {}) {
     const app = await platform.app.info(appIdentity);
     const allowedStack = 'container';
     if (app.build_stack.name !== allowedStack && app.stack.name !== allowedStack) {
-        throw new NotAContainerAppError({
-            // eslint-disable-next-line camelcase
-            build_stack: app.build_stack,
-            id: app.id,
-            name: app.name,
-            stack: app.stack,
-        });
+        throw new NotAContainerAppError(app);
     }
 }

package/dist/resources/platform/domain/test-utils.js

@@ -16,9 +16,11 @@ export function buildCtx(stubs = {}) {
     };
     platform.withOptions.mockReturnValue(platform);
     return {
+        dashboardBackend: {},
         data: {},
         metrics: {},
         platform: platform,
+        repositories: {},
     };
 }
 export function buildDomain(overrides = {}) {

package/dist/resources/platform/review-app-config/debug.d.ts

@@ -0,0 +1,2 @@
+import createDebug from 'debug';
+export declare const debug: createDebug.Debugger;

package/dist/resources/platform/review-app-config/debug.js

@@ -0,0 +1,2 @@
+import createDebug from 'debug';
+export const debug = createDebug('heroku:sdk:resources:review-app-config');

package/dist/resources/platform/review-app-config/index.d.ts

@@ -0,0 +1,5 @@
+import { type ResolveRepoNameOptions } from './resolve-repo-name.js';
+export { resolveRepoName, type ResolveRepoNameOptions } from './resolve-repo-name.js';
+export declare const reviewAppConfigExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "reviewAppConfig", {
+    resolveRepoName: (pipelineId: string, options?: ResolveRepoNameOptions) => Promise<string>;
+}>;

package/dist/resources/platform/review-app-config/index.js

@@ -0,0 +1,17 @@
+import { extendResource } from '../../../core/extend-resource.js';
+import { resolveRepoName } from './resolve-repo-name.js';
+export { resolveRepoName } from './resolve-repo-name.js';
+export const reviewAppConfigExtensions = extendResource('platform', 'reviewAppConfig', ctx => {
+    const { repositoriesApi } = ctx;
+    if (!repositoriesApi) {
+        throw new Error('reviewAppConfigExtensions requires ResourceCtx.repositoriesApi');
+    }
+    const resolveRepoNameCtx = {
+        platform: ctx.platform,
+        repositories: ctx.repositories,
+        repositoriesApi,
+    };
+    return {
+        resolveRepoName: (pipelineId, options) => resolveRepoName(resolveRepoNameCtx, pipelineId, options),
+    };
+});

package/dist/resources/platform/review-app-config/resolve-repo-name.d.ts

@@ -0,0 +1,16 @@
+import type { ResourceCtx } from '../../../core/extend-resource.js';
+type ResolveRepoNameCtx = Pick<ResourceCtx, 'platform' | 'repositories'> & {
+    repositoriesApi: NonNullable<ResourceCtx['repositoriesApi']>;
+};
+export type ResolveRepoNameOptions = {
+    signal?: AbortSignal;
+};
+/**
+ * Resolves the GitHub repository name for a canonical pipeline ID.
+ * Resolve user-supplied pipeline names before calling this helper.
+ * Uses Repositories API when the account feature is enabled, and falls back
+ * to the Kolkrabbi-backed repositories service when the feature is disabled,
+ * the feature lookup fails, or Repositories API cannot return a usable name.
+ */
+export declare function resolveRepoName(ctx: ResolveRepoNameCtx, pipelineId: string, options?: ResolveRepoNameOptions): Promise<string>;
+export {};

package/dist/resources/platform/review-app-config/resolve-repo-name.js

@@ -0,0 +1,54 @@
+import { debug } from './debug.js';
+/**
+ * Resolves the GitHub repository name for a canonical pipeline ID.
+ * Resolve user-supplied pipeline names before calling this helper.
+ * Uses Repositories API when the account feature is enabled, and falls back
+ * to the Kolkrabbi-backed repositories service when the feature is disabled,
+ * the feature lookup fails, or Repositories API cannot return a usable name.
+ */
+export async function resolveRepoName(ctx, pipelineId, options = {}) {
+    const { signal } = options;
+    signal?.throwIfAborted();
+    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    let useRepositoriesApi;
+    try {
+        const feature = await platform.accountFeature.info('dashboard-repositories-api');
+        signal?.throwIfAborted();
+        useRepositoriesApi = feature.enabled;
+    }
+    catch (error) {
+        signal?.throwIfAborted();
+        debug('feature lookup failed error=%s; falling back', describeError(error));
+    }
+    if (useRepositoriesApi) {
+        try {
+            const repositoriesApi = signal ? ctx.repositoriesApi.withOptions({ signal }) : ctx.repositoriesApi;
+            const repository = await repositoriesApi.githubRepository.info(pipelineId);
+            signal?.throwIfAborted();
+            const repositoryName = repository.full_name?.trim();
+            if (repositoryName) {
+                return repositoryName;
+            }
+            debug('repositories API returned no full name; falling back');
+        }
+        catch (error) {
+            signal?.throwIfAborted();
+            debug('repositories API lookup failed error=%s; falling back', describeError(error));
+        }
+    }
+    else if (useRepositoriesApi === false) {
+        signal?.throwIfAborted();
+        debug('repositories API disabled; falling back');
+    }
+    const repositories = signal ? ctx.repositories.withOptions({ signal }) : ctx.repositories;
+    const pipelineRepository = await repositories.pipelineRepository.info(pipelineId);
+    signal?.throwIfAborted();
+    const repositoryName = pipelineRepository.repository.name.trim();
+    if (!repositoryName) {
+        throw new Error('Repositories service returned no repository name');
+    }
+    return repositoryName;
+}
+function describeError(error) {
+    return error instanceof Error ? error.name : typeof error;
+}

package/dist/resources/platform/space/errors.d.ts

@@ -0,0 +1,28 @@
+import type { Space } from '@heroku/types/3.sdk';
+/**
+ * Thrown by `waitForAllocated` when the space settles into a terminal
+ * state other than `allocated` (e.g. `deleting`).
+ */
+export declare class SpaceNotAllocatedError extends Error {
+    readonly space: Space;
+    readonly id = "space_not_allocated";
+    constructor(space: Space);
+    get body(): {
+        id: string;
+        message: string;
+    };
+}
+/**
+ * Thrown by `waitForAllocated` when `timeoutMs` elapses while the space
+ * is still `allocating`.
+ */
+export declare class SpaceNotReadyError extends Error {
+    readonly space: Space;
+    readonly timeoutMs: number;
+    readonly id = "space_not_ready";
+    constructor(space: Space, timeoutMs: number);
+    get body(): {
+        id: string;
+        message: string;
+    };
+}

package/dist/resources/platform/space/errors.js

@@ -0,0 +1,34 @@
+/**
+ * Thrown by `waitForAllocated` when the space settles into a terminal
+ * state other than `allocated` (e.g. `deleting`).
+ */
+export class SpaceNotAllocatedError extends Error {
+    space;
+    id = 'space_not_allocated';
+    constructor(space) {
+        super(`The space ${space.name} did not become allocated, with state ${space.state}.`);
+        this.space = space;
+        this.name = 'SpaceNotAllocatedError';
+    }
+    get body() {
+        return { id: this.id, message: this.message };
+    }
+}
+/**
+ * Thrown by `waitForAllocated` when `timeoutMs` elapses while the space
+ * is still `allocating`.
+ */
+export class SpaceNotReadyError extends Error {
+    space;
+    timeoutMs;
+    id = 'space_not_ready';
+    constructor(space, timeoutMs) {
+        super(`Timeout waiting for space ${space.name} to become allocated.`);
+        this.space = space;
+        this.timeoutMs = timeoutMs;
+        this.name = 'SpaceNotReadyError';
+    }
+    get body() {
+        return { id: this.id, message: this.message };
+    }
+}

package/dist/resources/platform/space/index.d.ts

@@ -0,0 +1,7 @@
+import type { WaitForAllocatedOptions } from './types.js';
+export { SpaceNotAllocatedError, SpaceNotReadyError } from './errors.js';
+export type { SpaceOptions, WaitForAllocatedOptions } from './types.js';
+export { type SpaceWithNat, waitForAllocated } from './wait-for-allocated.js';
+export declare const spaceExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "space", {
+    waitForAllocated: (name: string, options?: WaitForAllocatedOptions) => Promise<import("./wait-for-allocated.js").SpaceWithNat>;
+}>;

package/dist/resources/platform/space/index.js

@@ -0,0 +1,7 @@
+import { extendResource } from '../../../core/extend-resource.js';
+import { waitForAllocated } from './wait-for-allocated.js';
+export { SpaceNotAllocatedError, SpaceNotReadyError } from './errors.js';
+export { waitForAllocated } from './wait-for-allocated.js';
+export const spaceExtensions = extendResource('platform', 'space', ctx => ({
+    waitForAllocated: (name, options) => waitForAllocated(ctx, name, options),
+}));

package/dist/resources/platform/space/types.d.ts

@@ -0,0 +1,25 @@
+export type SpaceOptions = {
+    signal?: AbortSignal;
+};
+export type WaitForAllocatedOptions = SpaceOptions & {
+    /**
+     * When true, once the space reaches a terminal state, also fetches
+     * the space's NAT info (`spaceNat.info`) and attaches it as `nat` on
+     * the result.
+     *
+     * Fetching NAT info is soft-failure: if it rejects, `nat` is left
+     * `undefined` on the returned space rather than failing the whole
+     * wait.
+     */
+    includeNat?: boolean;
+    /**
+     * Delay between polls in milliseconds.
+     * Defaults to 5000 (5s)
+     */
+    intervalMs?: number;
+    /**
+     * Wall-clock budget in milliseconds before `SpaceNotReadyError`
+     * is thrown. Defaults to 1200000 (20 minutes)
+     */
+    timeoutMs?: number;
+};

package/dist/resources/platform/space/types.js

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

package/dist/resources/platform/space/wait-for-allocated.d.ts

@@ -0,0 +1,29 @@
+import type { Space, SpaceNat } from '@heroku/types/3.sdk';
+import type { ResourceCtx } from '../../../core/extend-resource.js';
+import type { WaitForAllocatedOptions } from './types.js';
+export type SpaceWithNat = Space & {
+    /**
+     * The space's NAT info, attached when `options.includeNat` is set and
+     * the fetch succeeds. Left `undefined` if `includeNat` was not
+     * requested, or if the NAT fetch failed (soft-failure).
+     */
+    nat?: SpaceNat;
+};
+/**
+ * Poll `space.info` until the space's `state` is no longer `allocating`,
+ * then return it.
+ *
+ * If the terminal state is not `allocated` (e.g. `deleting`), throws
+ * `SpaceNotAllocatedError`. On exceeding `timeoutMs` without reaching a
+ * terminal state, throws `SpaceNotReadyError`.
+ *
+ * Each poll uses the SDK default `Accept: version=3.sdk` with
+ * `Accept-Expansion: region` to match the existing CLI behaviour.
+ *
+ * When `options.includeNat` is true and the space becomes allocated,
+ * also fetches `spaceNat.info` and attaches it as `nat` on the result.
+ * That fetch is soft-failure: if it rejects, `nat` is left `undefined`
+ * rather than failing the wait. A caller abort during the fetch is the
+ * exception — it is re-thrown rather than swallowed.
+ */
+export declare function waitForAllocated(ctx: Pick<ResourceCtx, 'platform'>, name: string, options?: WaitForAllocatedOptions): Promise<SpaceWithNat>;

package/dist/resources/platform/space/wait-for-allocated.js

@@ -0,0 +1,56 @@
+import { wait } from '../../../utils/wait.js';
+import { SpaceNotAllocatedError, SpaceNotReadyError } from './errors.js';
+const DEFAULT_INTERVAL_MS = 5000;
+const DEFAULT_TIMEOUT_MS = 20 * 60 * 1000;
+/**
+ * Poll `space.info` until the space's `state` is no longer `allocating`,
+ * then return it.
+ *
+ * If the terminal state is not `allocated` (e.g. `deleting`), throws
+ * `SpaceNotAllocatedError`. On exceeding `timeoutMs` without reaching a
+ * terminal state, throws `SpaceNotReadyError`.
+ *
+ * Each poll uses the SDK default `Accept: version=3.sdk` with
+ * `Accept-Expansion: region` to match the existing CLI behaviour.
+ *
+ * When `options.includeNat` is true and the space becomes allocated,
+ * also fetches `spaceNat.info` and attaches it as `nat` on the result.
+ * That fetch is soft-failure: if it rejects, `nat` is left `undefined`
+ * rather than failing the wait. A caller abort during the fetch is the
+ * exception — it is re-thrown rather than swallowed.
+ */
+export async function waitForAllocated(ctx, name, options = {}) {
+    const { includeNat, intervalMs = DEFAULT_INTERVAL_MS, signal, timeoutMs = DEFAULT_TIMEOUT_MS, } = options;
+    signal?.throwIfAborted();
+    let platform = ctx.platform.withHeaders({ 'Accept-Expansion': 'region' });
+    if (signal) {
+        platform = platform.withOptions({ signal });
+    }
+    const deadline = Date.now() + timeoutMs;
+    let space = await platform.space.info(name);
+    while (space.state === 'allocating') {
+        signal?.throwIfAborted();
+        if (Date.now() >= deadline) {
+            throw new SpaceNotReadyError(space, timeoutMs);
+        }
+        await wait(intervalMs, signal);
+        space = await platform.space.info(name);
+    }
+    if (space.state !== 'allocated') {
+        throw new SpaceNotAllocatedError(space);
+    }
+    if (!includeNat) {
+        return space;
+    }
+    try {
+        const nat = await platform.spaceNat.info(name);
+        return { ...space, nat };
+    }
+    catch {
+        // Soft-failure: a rejected NAT fetch leaves `nat` undefined rather than
+        // failing the wait — but a caller abort must not be swallowed here, so
+        // re-throw it if the signal aborted during the fetch.
+        signal?.throwIfAborted();
+        return space;
+    }
+}

package/dist/resources/platform/vpn-connection/index.d.ts

@@ -0,0 +1,8 @@
+import { type WaitForActiveOptions } from './wait-for-active.js';
+export { VpnConnectionFailedError, VpnConnectionNotReadyError, waitForActive, type WaitForActiveOptions, } from './wait-for-active.js';
+export type VpnConnectionOptions = {
+    signal?: AbortSignal;
+};
+export declare const vpnConnectionExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "vpnConnection", {
+    waitForActive: (spaceIdentity: string, vpnConnectionIdentity: string, options?: WaitForActiveOptions) => Promise<import("@heroku/types/3.sdk").VpnConnection>;
+}>;

package/dist/resources/platform/vpn-connection/index.js

@@ -0,0 +1,6 @@
+import { extendResource } from '../../../core/extend-resource.js';
+import { waitForActive } from './wait-for-active.js';
+export { VpnConnectionFailedError, VpnConnectionNotReadyError, waitForActive, } from './wait-for-active.js';
+export const vpnConnectionExtensions = extendResource('platform', 'vpnConnection', ctx => ({
+    waitForActive: (spaceIdentity, vpnConnectionIdentity, options) => waitForActive(ctx, spaceIdentity, vpnConnectionIdentity, options),
+}));

package/dist/resources/platform/vpn-connection/wait-for-active.d.ts

@@ -0,0 +1,39 @@
+import type { VpnConnection } from '@heroku/types/3.sdk';
+import type { ResourceCtx } from '../../../core/extend-resource.js';
+import type { Poller } from '../../../utils/poller.js';
+import type { VpnConnectionOptions } from './index.js';
+export declare class VpnConnectionFailedError extends Error {
+    readonly id = "vpn_connection_failed";
+    constructor(vpnConnection: VpnConnection);
+}
+export declare class VpnConnectionNotReadyError extends Error {
+    readonly timeoutMs: number;
+    readonly id = "vpn_connection_not_ready";
+    constructor(vpnConnection: VpnConnection, timeoutMs: number);
+}
+export type WaitForActiveOptions = VpnConnectionOptions & {
+    /**
+     * Delay between polls in milliseconds.
+     * Defaults to 10000 (10s)
+     */
+    intervalMs?: number;
+    /**
+     * Fires `poller.onStart` immediately before polling begins
+     * and `poller.onStop` once the connection becomes active.
+     */
+    poller?: Poller<VpnConnection>;
+    /**
+     * Wall-clock budget in milliseconds before {@link VpnConnectionNotReadyError}
+     * is thrown. Defaults to 1200000 (20 minutes)
+     */
+    timeoutMs?: number;
+};
+/**
+ * Poll `vpnConnection.info` until the connection's `status` is `active`,
+ * then return it.
+ *
+ * If `status` becomes `failed`, throws {@link VpnConnectionFailedError}.
+ * On exceeding `timeoutMs` without reaching `active` or `failed`, throws
+ * {@link VpnConnectionNotReadyError}.
+ */
+export declare function waitForActive(ctx: Pick<ResourceCtx, 'platform'>, spaceIdentity: string, vpnConnectionIdentity: string, options?: WaitForActiveOptions): Promise<VpnConnection>;

package/dist/resources/platform/vpn-connection/wait-for-active.js

@@ -0,0 +1,48 @@
+import { wait } from '../../../utils/wait.js';
+const DEFAULT_INTERVAL_MS = 10 * 1000;
+const DEFAULT_TIMEOUT_MS = 20 * 60 * 1000;
+export class VpnConnectionFailedError extends Error {
+    id = 'vpn_connection_failed';
+    constructor(vpnConnection) {
+        super(vpnConnection.status_message);
+        this.name = 'VpnConnectionFailedError';
+    }
+}
+export class VpnConnectionNotReadyError extends Error {
+    timeoutMs;
+    id = 'vpn_connection_not_ready';
+    constructor(vpnConnection, timeoutMs) {
+        super(`Timeout waiting for VPN connection ${vpnConnection.name} to become allocated.`);
+        this.timeoutMs = timeoutMs;
+        this.name = 'VpnConnectionNotReadyError';
+    }
+}
+/**
+ * Poll `vpnConnection.info` until the connection's `status` is `active`,
+ * then return it.
+ *
+ * If `status` becomes `failed`, throws {@link VpnConnectionFailedError}.
+ * On exceeding `timeoutMs` without reaching `active` or `failed`, throws
+ * {@link VpnConnectionNotReadyError}.
+ */
+export async function waitForActive(ctx, spaceIdentity, vpnConnectionIdentity, options = {}) {
+    const { intervalMs = DEFAULT_INTERVAL_MS, poller, signal, timeoutMs = DEFAULT_TIMEOUT_MS, } = options;
+    signal?.throwIfAborted();
+    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const deadline = Date.now() + timeoutMs;
+    let vpnConnection = await platform.vpnConnection.info(spaceIdentity, vpnConnectionIdentity);
+    poller?.onStart?.(vpnConnection);
+    while (vpnConnection.status !== 'active') {
+        signal?.throwIfAborted();
+        if (vpnConnection.status === 'failed') {
+            throw new VpnConnectionFailedError(vpnConnection);
+        }
+        if (Date.now() >= deadline) {
+            throw new VpnConnectionNotReadyError(vpnConnection, timeoutMs);
+        }
+        await wait(intervalMs, signal);
+        vpnConnection = await platform.vpnConnection.info(spaceIdentity, vpnConnectionIdentity);
+    }
+    poller?.onStop?.(vpnConnection);
+    return vpnConnection;
+}

package/dist/services/dashboard-backend.d.ts

@@ -0,0 +1,5 @@
+import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
+import type { HerokuClient } from '@heroku/types/dashboard-backend';
+import type { RoutesClientExtras } from '../core/create-client.js';
+export type DashboardBackendClient = HerokuClient & RoutesClientExtras<HerokuClient>;
+export declare function createDashboardBackendClient(options?: HerokuApiClientOptions): DashboardBackendClient;

package/dist/services/dashboard-backend.js

@@ -0,0 +1,10 @@
+import * as routes from '@heroku/types/dashboard-backend/routes';
+import { createClient } from '../core/create-client.js';
+export function createDashboardBackendClient(options = {}) {
+    const baseUrl = process.env.HEROKU_PARTICLEBOARD_URL;
+    return createClient(routes, {
+        service: 'particleboard',
+        ...(baseUrl && { baseUrl }),
+        ...options,
+    });
+}

package/dist/services/repositories-api.d.ts

@@ -0,0 +1,5 @@
+import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
+import type { HerokuClient } from '@heroku/types/repositories-api';
+import type { RoutesClientExtras } from '../core/create-client.js';
+export type RepositoriesApiClient = HerokuClient & RoutesClientExtras<HerokuClient>;
+export declare function createRepositoriesApiClient(options?: HerokuApiClientOptions): RepositoriesApiClient;

package/dist/services/repositories-api.js

@@ -0,0 +1,10 @@
+import * as routes from '@heroku/types/repositories-api/routes';
+import { createClient } from '../core/create-client.js';
+const REPOSITORIES_API_ACCEPT = 'application/vnd.heroku+json; version=3.repositories-api';
+export function createRepositoriesApiClient(options = {}) {
+    return createClient(routes, {
+        defaultAccept: REPOSITORIES_API_ACCEPT,
+        service: 'platform',
+        ...options,
+    });
+}

package/dist/services/repositories.d.ts

@@ -0,0 +1,5 @@
+import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
+import type { HerokuClient } from '@heroku/types/repositories';
+import type { RoutesClientExtras } from '../core/create-client.js';
+export type RepositoriesClient = HerokuClient & RoutesClientExtras<HerokuClient>;
+export declare function createRepositoriesClient(options?: HerokuApiClientOptions): RepositoriesClient;

package/dist/services/repositories.js

@@ -0,0 +1,11 @@
+import * as routes from '@heroku/types/repositories/routes';
+import { createClient } from '../core/create-client.js';
+const DEFAULT_REPOSITORIES_BASE_URL = 'https://kolkrabbi.heroku.com';
+export function createRepositoriesClient(options = {}) {
+    const baseUrl = process.env.HEROKU_REPOSITORIES_HOST ?? DEFAULT_REPOSITORIES_BASE_URL;
+    return createClient(routes, {
+        baseUrl,
+        service: 'custom',
+        ...options,
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heroku/sdk",
-  "version": "0.5.7",
+  "version": "0.6.1",
   "description": "Heroku SDK",
   "author": "Heroku",
   "type": "module",
@@ -18,10 +18,22 @@
       "types": "./dist/services/data.d.ts",
       "default": "./dist/services/data.js"
     },
+    "./dashboard-backend": {
+      "types": "./dist/services/dashboard-backend.d.ts",
+      "default": "./dist/services/dashboard-backend.js"
+    },
     "./metrics": {
       "types": "./dist/services/metrics.d.ts",
       "default": "./dist/services/metrics.js"
     },
+    "./repositories": {
+      "types": "./dist/services/repositories.d.ts",
+      "default": "./dist/services/repositories.js"
+    },
+    "./repositories-api": {
+      "types": "./dist/services/repositories-api.d.ts",
+      "default": "./dist/services/repositories-api.js"
+    },
     "./extensions/platform": {
       "types": "./dist/resources/extensions/platform.d.ts",
       "default": "./dist/resources/extensions/platform.js"
@@ -38,6 +50,14 @@
       "types": "./dist/resources/platform/app/index.d.ts",
       "default": "./dist/resources/platform/app/index.js"
     },
+    "./resources/platform/container": {
+      "types": "./dist/resources/platform/container/index.d.ts",
+      "default": "./dist/resources/platform/container/index.js"
+    },
+    "./resources/platform/domain": {
+      "types": "./dist/resources/platform/domain/index.d.ts",
+      "default": "./dist/resources/platform/domain/index.js"
+    },
     "./resources/platform/dyno": {
       "types": "./dist/resources/platform/dyno/index.d.ts",
       "default": "./dist/resources/platform/dyno/index.js"
@@ -54,10 +74,26 @@
       "types": "./dist/resources/platform/pipeline/*.d.ts",
       "default": "./dist/resources/platform/pipeline/*.js"
     },
+    "./resources/platform/review-app-config": {
+      "types": "./dist/resources/platform/review-app-config/index.d.ts",
+      "default": "./dist/resources/platform/review-app-config/index.js"
+    },
+    "./resources/platform/sni-endpoint": {
+      "types": "./dist/resources/platform/sni-endpoint/index.d.ts",
+      "default": "./dist/resources/platform/sni-endpoint/index.js"
+    },
+    "./resources/platform/telemetry-drain": {
+      "types": "./dist/resources/platform/telemetry-drain/index.d.ts",
+      "default": "./dist/resources/platform/telemetry-drain/index.js"
+    },
     "./resources/platform/test-run": {
       "types": "./dist/resources/platform/test-run/index.d.ts",
       "default": "./dist/resources/platform/test-run/index.js"
     },
+    "./resources/platform/vpn-connection": {
+      "types": "./dist/resources/platform/vpn-connection/index.d.ts",
+      "default": "./dist/resources/platform/vpn-connection/index.js"
+    },
     "./resources/data/redis": {
       "types": "./dist/resources/data/redis/index.d.ts",
       "default": "./dist/resources/data/redis/index.js"
@@ -80,7 +116,8 @@
     "lint:fix": "eslint --fix",
     "prebuild": "rimraf dist",
     "prepare": "npm run build",
-    "test": "vitest --run"
+    "test": "vitest --run",
+    "test:types": "tsc --noEmit -p tsconfig.type-tests.json"
   },
   "license": "Apache-2.0",
   "engines": {
@@ -104,7 +141,7 @@
   },
   "dependencies": {
     "@heroku/heroku-fetch": "^0.1.4",
-    "@heroku/types": "^4.1.0",
+    "@heroku/types": "^4.7.0",
     "debug": "^4.4.0"
   }
 }