heroku 11.0.0-alpha.11 → 11.0.0-alpha.12

package/lib/lib/container/docker_helper.d.ts

@@ -1,34 +1,34 @@
 export declare type CmdOptions = {
-    output?: boolean;
     input?: string;
+    output?: boolean;
 };
 export declare type DockerJob = {
-    name: string;
-    resource: string;
+    depth: number;
     dockerfile: string;
+    name: string;
     postfix: number;
-    depth: number;
+    resource: string;
 };
 export declare type GroupedDockerJobs = {
     [processType: string]: DockerJob[];
 };
 declare type BuildImageParams = {
-    dockerfile: string;
-    resource: string;
+    arch?: string;
     buildArgs: string[];
+    dockerfile: string;
     path?: string;
-    arch?: string;
+    resource: string;
 };
 export declare class DockerHelper {
+    buildImage({ arch, buildArgs, dockerfile, path, resource }: BuildImageParams): Promise<string>;
+    chooseJobs(jobs: GroupedDockerJobs): Promise<DockerJob[]>;
     cmd(cmd: string, args: string[], options?: CmdOptions): Promise<string>;
-    version(): Promise<[number, number]>;
-    pullImage(resource: string): Promise<string>;
+    filterByProcessType(jobs: GroupedDockerJobs, processTypes: string[]): GroupedDockerJobs;
     getDockerfiles(rootdir: string, recursive: boolean): string[];
     getJobs(resourceRoot: string, dockerfiles: string[]): GroupedDockerJobs;
-    filterByProcessType(jobs: GroupedDockerJobs, processTypes: string[]): GroupedDockerJobs;
-    chooseJobs(jobs: GroupedDockerJobs): Promise<DockerJob[]>;
-    buildImage({ dockerfile, resource, buildArgs, path, arch }: BuildImageParams): Promise<string>;
+    pullImage(resource: string): Promise<string>;
     pushImage(resource: string, arch: string): Promise<string>;
     runImage(resource: string, command: string, port: number): Promise<string>;
+    version(): Promise<[number, number]>;
 }
 export {};

package/lib/lib/container/docker_helper.js

@@ -1,12 +1,61 @@
-import Child from 'node:child_process';
-import { debug } from './debug.js';
+import { ux } from '@oclif/core';
 import { glob } from 'glob';
-import Path from 'node:path';
 import inquirer from 'inquirer';
+import Child from 'node:child_process';
 import os from 'node:os';
-import { ux } from '@oclif/core';
+import Path from 'node:path';
+import { debug } from './debug.js';
 const DOCKERFILE_REGEX = /\bDockerfile(.\w*)?$/;
 export class DockerHelper {
+    async buildImage({ arch, buildArgs, dockerfile, path, resource }) {
+        const cwd = path || Path.dirname(dockerfile);
+        const args = ['build', '-f', dockerfile, '-t', resource];
+        // Older Docker versions don't allow for this flag, but we are
+        // adding it here when necessary to allow for pushing a docker build from m1/m2 Macs.
+        if (arch === 'arm64' || arch === 'aarch64')
+            args.push('--platform', 'linux/amd64');
+        // newer docker versions support attestations and software bill of materials, so we want to disable them to save time/space
+        // Heroku's container registry doesn't support pushing them right now
+        if (await this.version() >= [24, 0, 0]) {
+            args.push('--provenance', 'false', '--sbom', 'false');
+        }
+        for (const element of buildArgs) {
+            if (element.length > 0) {
+                args.push('--build-arg', element);
+            }
+        }
+        args.push(cwd);
+        return this.cmd('docker', args);
+    }
+    async chooseJobs(jobs) {
+        const chosenJobs = [];
+        for (const processType in jobs) {
+            if (Object.hasOwn(jobs, processType)) {
+                const group = jobs[processType];
+                if (group === undefined) {
+                    ux.warn(`Dockerfile.${processType} not found`);
+                    continue;
+                }
+                if (group.length > 1) {
+                    const prompt = [{
+                            choices: group.map(j => j.dockerfile),
+                            message: `Found multiple Dockerfiles with process type ${processType}. Please choose one to build and push `,
+                            name: processType,
+                            type: 'list',
+                        }];
+                    const answer = await inquirer.prompt(prompt);
+                    const found = group.find(o => o.dockerfile === answer[processType]);
+                    if (found) {
+                        chosenJobs.push(found);
+                    }
+                }
+                else {
+                    chosenJobs.push(group[0]);
+                }
+            }
+        }
+        return chosenJobs;
+    }
     async cmd(cmd, args, options = {}) {
         debug(cmd, args);
         const stdio = [
@@ -15,7 +64,7 @@ export class DockerHelper {
             process.stderr,
         ];
         return new Promise((resolve, reject) => {
-            const child = Child.spawn(cmd, args, { stdio: stdio });
+            const child = Child.spawn(cmd, args, { stdio });
             if (child.stdin) {
                 child.stdin.end(options.input);
             }
@@ -45,14 +94,12 @@ export class DockerHelper {
             });
         });
     }
-    async version() {
-        const version = await this.cmd('docker', ['version', '-f', '{{.Client.Version}}'], { output: true });
-        const [major, minor] = version.split(/\./);
-        return [Number.parseInt(major, 10) || 0, Number.parseInt(minor, 10) || 0]; // ensure exactly 2 components
-    }
-    async pullImage(resource) {
-        const args = ['pull', resource];
-        return this.cmd('docker', args);
+    filterByProcessType(jobs, processTypes) {
+        const filteredJobs = {};
+        processTypes.forEach(processType => {
+            filteredJobs[processType] = jobs[processType];
+        });
+        return filteredJobs;
     }
     getDockerfiles(rootdir, recursive) {
         const match = recursive ? './**/Dockerfile?(.)*' : 'Dockerfile*';
@@ -75,18 +122,16 @@ export class DockerHelper {
             if (match) {
                 const proc = (match[1] || '.standard').slice(1);
                 jobs.push({
+                    depth: Path.normalize(dockerfile).split(Path.sep).length,
+                    dockerfile,
                     name: proc,
-                    resource: `${resourceRoot}/${proc}`,
-                    dockerfile: dockerfile,
                     postfix: Path.basename(dockerfile) === 'Dockerfile' ? 0 : 1,
-                    depth: Path.normalize(dockerfile).split(Path.sep).length,
+                    resource: `${resourceRoot}/${proc}`,
                 });
             }
         });
         // prefer closer Dockerfiles, then prefer Dockerfile over Dockerfile.web
-        jobs.sort((a, b) => {
-            return a.depth - b.depth || a.postfix - b.postfix;
-        });
+        jobs.sort((a, b) => a.depth - b.depth || a.postfix - b.postfix);
         // group all Dockerfiles for the same process type together
         const groupedJobs = {};
         jobs.forEach(job => {
@@ -95,61 +140,8 @@ export class DockerHelper {
         });
         return groupedJobs;
     }
-    filterByProcessType(jobs, processTypes) {
-        const filteredJobs = {};
-        processTypes.forEach(processType => {
-            filteredJobs[processType] = jobs[processType];
-        });
-        return filteredJobs;
-    }
-    async chooseJobs(jobs) {
-        const chosenJobs = [];
-        for (const processType in jobs) {
-            if (Object.prototype.hasOwnProperty.call(jobs, processType)) {
-                const group = jobs[processType];
-                if (group === undefined) {
-                    ux.warn(`Dockerfile.${processType} not found`);
-                    continue;
-                }
-                if (group.length > 1) {
-                    const prompt = [{
-                            type: 'list',
-                            name: processType,
-                            choices: group.map(j => j.dockerfile),
-                            message: `Found multiple Dockerfiles with process type ${processType}. Please choose one to build and push `,
-                        }];
-                    const answer = await inquirer.prompt(prompt);
-                    const found = group.find(o => o.dockerfile === answer[processType]);
-                    if (found) {
-                        chosenJobs.push(found);
-                    }
-                }
-                else {
-                    chosenJobs.push(group[0]);
-                }
-            }
-        }
-        return chosenJobs;
-    }
-    async buildImage({ dockerfile, resource, buildArgs, path, arch }) {
-        const cwd = path || Path.dirname(dockerfile);
-        const args = ['build', '-f', dockerfile, '-t', resource];
-        // Older Docker versions don't allow for this flag, but we are
-        // adding it here when necessary to allow for pushing a docker build from m1/m2 Macs.
-        if (arch === 'arm64' || arch === 'aarch64')
-            args.push('--platform', 'linux/amd64');
-        // newer docker versions support attestations and software bill of materials, so we want to disable them to save time/space
-        // Heroku's container registry doesn't support pushing them right now
-        if (await this.version() >= [24, 0, 0]) {
-            args.push('--provenance', 'false');
-            args.push('--sbom', 'false');
-        }
-        for (const element of buildArgs) {
-            if (element.length > 0) {
-                args.push('--build-arg', element);
-            }
-        }
-        args.push(cwd);
+    async pullImage(resource) {
+        const args = ['pull', resource];
         return this.cmd('docker', args);
     }
     async pushImage(resource, arch) {
@@ -174,6 +166,11 @@ export class DockerHelper {
         ];
         return this.cmd('docker', args);
     }
+    async version() {
+        const version = await this.cmd('docker', ['version', '-f', '{{.Client.Version}}'], { output: true });
+        const [major, minor] = version.split(/\./);
+        return [Number.parseInt(major, 10) || 0, Number.parseInt(minor, 10) || 0]; // ensure exactly 2 components
+    }
 }
 // // Create a default instance for backward compatibility
 // const defaultDockerHelper = new DockerHelper()

package/lib/lib/container/helpers.js

@@ -1,4 +1,4 @@
-import { color } from '@heroku-cli/color';
+import { color } from '@heroku/heroku-cli-util';
 import { ux } from '@oclif/core';
 const stackLabelMap = {
     cnb: 'Cloud Native Buildpack',
@@ -17,7 +17,7 @@ export function ensureContainerStack(app, cmd) {
     if (buildStack !== allowedStack && appStack !== allowedStack) {
         let message = 'This command is for Docker apps only.';
         if (['push', 'release'].includes(cmd)) {
-            message += ` Switch stacks by running ${color.cmd('heroku stack:set container')}. Or, to deploy ${color.app(app.name)} with ${color.yellow(appStack)}, run ${color.cmd('git push heroku main')} instead.`;
+            message += ` Switch stacks by running ${color.code('heroku stack:set container')}. Or, to deploy ${color.app(app.name ?? '')} with ${color.name(appStack ?? '')}, run ${color.code('git push heroku main')} instead.`;
         }
         ux.error(message, { exit: 1 });
     }

package/lib/lib/container/streamer.js

@@ -3,18 +3,18 @@ async function call(url, out, retries) {
     const maxRetries = 30;
     try {
         const { response } = await HTTP.stream(url);
-        response.on('data', function (d) {
+        response.on('data', (d) => {
             out.write(d);
         });
-        return await new Promise(function (resolve, reject) {
+        return await new Promise((resolve, reject) => {
             response.on('error', reject);
             response.on('end', resolve);
         });
     }
     catch (error) {
         if (error.statusCode === 404 && retries <= maxRetries) {
-            return new Promise(function (resolve, reject) {
-                setTimeout(function () {
+            return new Promise((resolve, reject) => {
+                setTimeout(() => {
                     call(url, out, retries + 1).then(resolve, reject);
                 }, 1000);
             });

package/lib/lib/data/baseCommand.d.ts

@@ -0,0 +1,4 @@
+import { APIClient, Command } from '@heroku-cli/command';
+export default abstract class extends Command {
+    get dataApi(): APIClient;
+}

package/lib/lib/data/baseCommand.js

@@ -0,0 +1,15 @@
+import { utils } from '@heroku/heroku-cli-util';
+import { APIClient, Command } from '@heroku-cli/command';
+export default class extends Command {
+    get dataApi() {
+        const client = new APIClient(this.config);
+        client.defaults.host = utils.pg.host();
+        client.defaults.headers = {
+            ...this.heroku.defaults.headers,
+        };
+        if (process.env.HEROKU_DATA_CONTROL_PLANE) {
+            client.defaults.headers['X-Data-Control-Plane'] = process.env.HEROKU_DATA_CONTROL_PLANE;
+        }
+        return client;
+    }
+}

package/lib/lib/data/createPool.d.ts

@@ -0,0 +1,4 @@
+import { APIClient } from '@heroku-cli/command';
+import { AddOn } from '@heroku-cli/schema';
+import type { CreatePoolParameters, PoolInfoResponse } from './types.js';
+export default function createPool(dataApi: APIClient, addon: AddOn, parameters: CreatePoolParameters): Promise<PoolInfoResponse>;

package/lib/lib/data/createPool.js

@@ -0,0 +1,6 @@
+export default async function createPool(dataApi, addon, parameters) {
+    const { body: poolInfo } = await dataApi.post(`/data/postgres/v1/${addon.id}/pools`, {
+        body: parameters,
+    });
+    return poolInfo;
+}

package/lib/lib/data/credentialUtils.d.ts

@@ -0,0 +1,3 @@
+import type { CredentialInfo } from './types.js';
+export declare function sortByOwnerAndName(credentials: CredentialInfo[]): CredentialInfo[];
+export declare function isOwnerCredential(cred: CredentialInfo): boolean;

package/lib/lib/data/credentialUtils.js

@@ -0,0 +1,23 @@
+// NEW This is new. something similar exists in core: packages/cli/src/commands/pg/credentials.ts:61
+// protected sortByDefaultAndName(credentials: CredentialsInfo) {
+//  return credentials.sort((a, b) => {
+//    const isDefaultA = this.isDefaultCredential(a)
+//    const isDefaultB = this.isDefaultCredential(b)
+//
+//    return isDefaultB < isDefaultA ? -1 : (isDefaultA < isDefaultB ? 1 : a.name.localeCompare(b.name))
+//  })
+// }
+export function sortByOwnerAndName(credentials) {
+    return credentials.sort((a, b) => {
+        const isOwnerA = isOwnerCredential(a);
+        const isOwnerB = isOwnerCredential(b);
+        return isOwnerB < isOwnerA ? -1 : (isOwnerA < isOwnerB ? 1 : a.name.localeCompare(b.name));
+    });
+}
+// NEW This is new because we are now sorting on type instead of the name: packages/cli/src/commands/pg/credentials.ts:70
+// protected isDefaultCredential(cred: CredentialInfo): boolean {
+//  return cred.name === 'default'
+// }
+export function isOwnerCredential(cred) {
+    return cred.type === 'owner';
+}

package/lib/lib/data/displayQuota.d.ts

@@ -0,0 +1,19 @@
+import type { Quota } from './types.js';
+/**
+ * @description Formats a quota object into a human-readable status string.
+ *
+ * The status string includes the current usage of the quota, the critical quota limit, and the compliance message.
+ *
+ * @param {Quota} quota - The quota object to format.
+ *
+ * @returns {string} The formatted status string.
+ */
+export declare const formatQuotaStatus: (quota: Quota) => string;
+/**
+ * @description Displays a quota object in a human-readable format.
+ *
+ * @param {Quota} quota - The quota object to display.
+ *
+ * @returns {void}
+ */
+export declare const displayQuota: (quota: Quota) => void;

package/lib/lib/data/displayQuota.js

@@ -0,0 +1,59 @@
+import { hux } from '@heroku/heroku-cli-util';
+/**
+ * @description Returns a string describing the current quota compliance status.
+ *
+ * The compliance status is determined by evaluating the current usage against the warning and critical quotas.
+ * If no quotas are set, the function returns "(No quotas set)".
+ * If the current usage exceeds the critical quota and enforcement is active, the function returns "(Restricted)".
+ * If the current usage exceeds the critical quota, the function returns "(Exceeded configured critical quota)".
+ * If the current usage exceeds the warning quota, the function returns "(Exceeded configured warning quota)".
+ * Otherwise, the function returns "(Within configured quotas)".
+ *
+ * @param {Quota} quota - The quota object to evaluate.
+ * @returns {string} - A string describing the current quota compliance status.
+ */
+function getComplianceMessage(quota) {
+    const currentUsage = quota.current_gb ?? 0;
+    if (!quota.critical_gb && !quota.warning_gb)
+        return '(No quotas set)';
+    if (quota.critical_gb && currentUsage > quota.critical_gb && quota.enforcement_active)
+        return '(Restricted)';
+    if (quota.critical_gb && currentUsage > quota.critical_gb)
+        return '(Exceeded configured critical quota)';
+    if (quota.warning_gb && currentUsage > quota.warning_gb)
+        return '(Exceeded configured warning quota)';
+    return '(Within configured quotas)';
+}
+/**
+ * @description Formats a quota object into a human-readable status string.
+ *
+ * The status string includes the current usage of the quota, the critical quota limit, and the compliance message.
+ *
+ * @param {Quota} quota - The quota object to format.
+ *
+ * @returns {string} The formatted status string.
+ */
+export const formatQuotaStatus = (quota) => {
+    const complianceMessage = getComplianceMessage(quota);
+    const currentUsage = quota.current_gb ?? 0;
+    const usagePercentOfCriticalQuota = quota.critical_gb ? (currentUsage / quota.critical_gb) * 100 : null;
+    const usageMessage = `${hux.toHumanReadableDataSize(currentUsage)}${quota.critical_gb ? ` / ${hux.toHumanReadableDataSize(quota.critical_gb)}` : ''}${usagePercentOfCriticalQuota ? ` (${usagePercentOfCriticalQuota.toFixed(2)}%)` : ''}`;
+    return `${usageMessage} ${complianceMessage}`;
+};
+/**
+ * @description Displays a quota object in a human-readable format.
+ *
+ * @param {Quota} quota - The quota object to display.
+ *
+ * @returns {void}
+ */
+export const displayQuota = (quota) => {
+    hux.styledHeader(hux.toTitleCase(quota.type) || '');
+    hux.styledObject({
+        Warning: quota.warning_gb ? hux.toHumanReadableDataSize(quota.warning_gb) : 'Not set',
+        // eslint-disable-next-line perfectionist/sort-objects
+        Critical: quota.critical_gb ? hux.toHumanReadableDataSize(quota.critical_gb) : 'Not set',
+        'Enforcement Action': hux.toTitleCase(quota.enforcement_action),
+        Status: formatQuotaStatus(quota),
+    }, ['Warning', 'Critical', 'Enforcement Action', 'Status']);
+};

package/lib/lib/data/parseProvisionOpts.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Parses provision options from an array of KEY:VALUE or KEY strings.
+ *
+ * @param provisionOpts - Array of strings in KEY:VALUE or KEY format
+ * @returns Record mapping keys to values (keys without values default to "true")
+ *
+ * @example
+ * parseProvisionOpts(['fork:DATABASE', 'rollback:true', 'follow:', 'foo'])
+ * // Returns: { fork: 'DATABASE', rollback: 'true', follow: 'true', foo: 'true' }
+ *
+ * @example
+ * parseProvisionOpts(['key:value:with:colons'])
+ * // Returns: { key: 'value:with:colons' } (splits on first colon only)
+ */
+export declare function parseProvisionOpts(provisionOpts: string[]): Record<string, string>;

package/lib/lib/data/parseProvisionOpts.js

@@ -0,0 +1,31 @@
+/**
+ * Parses provision options from an array of KEY:VALUE or KEY strings.
+ *
+ * @param provisionOpts - Array of strings in KEY:VALUE or KEY format
+ * @returns Record mapping keys to values (keys without values default to "true")
+ *
+ * @example
+ * parseProvisionOpts(['fork:DATABASE', 'rollback:true', 'follow:', 'foo'])
+ * // Returns: { fork: 'DATABASE', rollback: 'true', follow: 'true', foo: 'true' }
+ *
+ * @example
+ * parseProvisionOpts(['key:value:with:colons'])
+ * // Returns: { key: 'value:with:colons' } (splits on first colon only)
+ */
+export function parseProvisionOpts(provisionOpts) {
+    const provisionConfig = {};
+    for (const opt of provisionOpts) {
+        const colonIndex = opt.indexOf(':');
+        if (colonIndex === -1) {
+            // No colon means just a key, default to "true"
+            provisionConfig[opt.trim()] = 'true';
+        }
+        else {
+            const key = opt.slice(0, colonIndex).trim();
+            const value = opt.slice(colonIndex + 1).trim();
+            // If no value is provided after the colon, default to "true"
+            provisionConfig[key] = value || 'true';
+        }
+    }
+    return provisionConfig;
+}

package/lib/lib/data/types.d.ts

@@ -0,0 +1,177 @@
+export declare type DeepRequired<T> = T extends object ? {
+    [K in keyof T]-?: DeepRequired<T[K]>;
+} : T;
+declare type ResourceReference = {
+    id: string;
+    name: string;
+};
+declare type AppReference = ResourceReference;
+declare type AddonReference = ResourceReference;
+declare type CommonRuntimeRegion = 'eu' | 'us';
+declare type PrivateSpaceRegion = 'california' | 'dublin' | 'frankfurt' | 'london' | 'montreal' | 'mumbai' | 'ohio' | 'oregon' | 'paris' | 'singapore' | 'sydney' | 'tokyo' | 'virginia';
+export declare type InfoResponse = {
+    addon: AddonReference;
+    app: AppReference;
+    created_at: string;
+    features: {
+        continuous_protection: {
+            enabled: boolean;
+        };
+        credentials: {
+            current_count: number;
+            enabled: boolean;
+        };
+        data_encryption: {
+            enabled: boolean;
+        };
+        fork: {
+            enabled: boolean;
+        };
+        highly_available: {
+            enabled: boolean;
+        };
+        rollback: {
+            earliest_time: null | string;
+            enabled: boolean;
+            latest_time: null | string;
+        };
+    };
+    forked_from: AddonReference | null;
+    plan_limits: Array<PlanLimit>;
+    pools: Array<PoolInfoResponse>;
+    quotas: Array<Quota>;
+    region: CommonRuntimeRegion | PrivateSpaceRegion;
+    status: 'available' | 'modifying' | 'provisioning' | 'unavailable';
+    tier: 'advanced';
+    version: string;
+};
+export declare type Quotas = {
+    items: Array<Quota>;
+};
+export declare type Quota = {
+    critical_gb: null | number;
+    current_gb: null | number;
+    enforcement_action: 'none' | 'notify' | 'restrict';
+    enforcement_active: boolean;
+    type: string;
+    warning_gb: null | number;
+};
+declare type TableLimit = {
+    current: number;
+    limit: number;
+    name: 'table-limit';
+};
+declare type ConnectionLimit = {
+    current: number;
+    limit: number;
+    name: 'connection-limit';
+};
+declare type StorageLimitInGb = {
+    current: number;
+    limit: number;
+    name: 'storage-limit-in-gb';
+};
+export declare type PlanLimit = ConnectionLimit | StorageLimitInGb | TableLimit;
+export declare type PostgresLevelInfo = {
+    memory_in_gb: number;
+    name: string;
+    vcpu: number;
+};
+export declare type PostgresLevelsResponse = {
+    items: Array<PostgresLevelInfo>;
+};
+declare type BaseChange = {
+    current: boolean | null | number | string;
+    name: string;
+    previous: boolean | null | number | string;
+};
+declare type PoolChange = {
+    pool: string;
+} & BaseChange;
+export declare type ScaleResponse = {
+    changes: Array<PoolChange>;
+};
+declare type SettingsChange = BaseChange;
+export declare type SettingsChangeResponse = {
+    changes: Array<SettingsChange>;
+};
+export declare type SettingsResponse = {
+    items: Array<{
+        current: boolean | null | number | string;
+        default: boolean | null | number | string;
+        name: string;
+        reboot_required: boolean;
+    }>;
+};
+export declare type CreatePoolParameters = {
+    count: number;
+    level: string;
+    name?: string;
+};
+export declare type ComputeInstance = {
+    id: string;
+    level: string;
+    name: string;
+    role: string;
+    status: string;
+    updated_at: string;
+};
+export declare type ConnectionEndpoint = {
+    host: string;
+    port: number;
+    status: 'available' | 'degraded' | 'deprovisioning' | 'modifying';
+};
+export declare type PoolInfoResponse = {
+    compute_instances: Array<ComputeInstance>;
+    endpoints: Array<ConnectionEndpoint>;
+    expected_count: number;
+    expected_level: string;
+    id: string;
+    name: string;
+    status: 'available' | 'modifying';
+};
+export declare type CredentialsInfo = {
+    items: Array<AdvancedCredentialInfo>;
+};
+export declare type CredentialInfo = AdvancedCredentialInfo | NonAdvancedCredentialInfo;
+export interface AdvancedCredentialInfo extends Record<string, unknown> {
+    database: string;
+    host: string;
+    id: string;
+    name: string;
+    port: string;
+    roles: Array<{
+        password: string;
+        state: string;
+        user: string;
+    }>;
+    state: string;
+    type: 'additional' | 'owner';
+}
+export declare function isAdvancedCredentialInfo(credential: CredentialInfo): credential is AdvancedCredentialInfo;
+export declare type PricingInfo = {
+    billing_period: 'month';
+    billing_unit: 'compute' | 'gigabyte';
+    included_units?: number;
+    product_description: string;
+    rate: number;
+};
+export declare type TierPricingInfo = Record<string, PricingInfo>;
+export declare type PricingInfoResponse = Record<string, TierPricingInfo>;
+export interface NonAdvancedCredentialInfo extends Record<string, unknown> {
+    credentials: Array<{
+        password: string;
+        state: string;
+        user: string;
+    }>;
+    database: string;
+    host: string;
+    name: string;
+    port: string;
+    state: string;
+    uuid: string;
+}
+export declare type ExtendedPostgresLevelInfo = {
+    pricing: PricingInfo | undefined;
+} & PostgresLevelInfo;
+export {};

package/lib/lib/data/types.js

@@ -0,0 +1,3 @@
+export function isAdvancedCredentialInfo(credential) {
+    return 'type' in credential;
+}

package/lib/lib/data-scrubber/patterns.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Regex patterns for detecting PII in string content
+ */
+export declare const PII_PATTERNS: RegExp[];