heroku 9.0.0-alpha.0 → 9.0.0-alpha.2

package/lib/lib/redis/api.d.ts

@@ -0,0 +1,65 @@
+import * as Heroku from '@heroku-cli/schema';
+import { APIClient } from '@heroku-cli/command';
+export declare type RedisFormationResponse = {
+    addon_id: string;
+    name: string;
+    plan: string;
+    created_at: string;
+    formation: {
+        id: string;
+        primary: string | null;
+    };
+    metaas_source: string;
+    port: number;
+    resource_url: string;
+    info: {
+        name: string;
+        values: string[];
+    }[];
+    version: string;
+    prefer_native_tls: boolean;
+    customer_encryption_key?: string;
+};
+declare type RedisEvictionPolicies = 'noeviction' | 'allkeys-lru' | 'volatile-lru' | 'allkeys-random' | 'volatile-random' | 'volatile-ttl' | 'allkeys-lfu' | 'volatile-lfu';
+export declare type RedisApiResponse = {
+    message: string;
+};
+export declare type RedisFormationConfigResponse = {
+    maxmemory_policy: {
+        desc: string;
+        value: RedisEvictionPolicies;
+        default: RedisEvictionPolicies;
+        values: Record<RedisEvictionPolicies, string>;
+    };
+    notify_keyspace_events: {
+        desc: string;
+        value: string;
+        default: string;
+    };
+    timeout: {
+        desc: string;
+        value: number;
+        default: number;
+    };
+    standby_segv_workaround: {
+        desc: string;
+        value: boolean;
+        default: boolean;
+    };
+};
+export declare type RedisMaintenanceWindowResponse = {
+    window: string | null;
+    scheduled_at?: string;
+};
+export declare type RedisFormationWaitResponse = {
+    message: string;
+    'waiting?': boolean;
+};
+declare type HttpVerb = 'GET' | 'POST' | 'PATCH' | 'DELETE' | 'PUT';
+declare const _default: (app: string, database: string | undefined, json: boolean, heroku: APIClient) => {
+    request<T>(path: string, method?: HttpVerb, body?: {}): Promise<import("http-call").HTTP<T>>;
+    makeAddonsFilter(filter: string | undefined): (addons: Required<Heroku.AddOn>[]) => Required<Heroku.AddOn>[];
+    getRedisAddon(addons?: Required<Heroku.AddOn>[]): Promise<Required<Heroku.AddOn>>;
+    info(): Promise<void>;
+};
+export default _default;

package/lib/lib/redis/api.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+exports.default = (app, database, json, heroku) => {
+    const HOST = process.env.HEROKU_REDIS_HOST || 'api.data.heroku.com';
+    const ADDON = process.env.HEROKU_REDIS_ADDON_NAME || 'heroku-redis';
+    return {
+        request(path, method = 'GET', body = {}) {
+            const headers = { Accept: 'application/json' };
+            if (process.env.HEROKU_HEADERS) {
+                Object.assign(headers, JSON.parse(process.env.HEROKU_HEADERS));
+            }
+            return heroku.request(path, {
+                hostname: HOST,
+                method,
+                headers,
+                body,
+            });
+        },
+        makeAddonsFilter(filter) {
+            if (filter) {
+                filter = filter.toUpperCase();
+            }
+            function matches(addon) {
+                const configVars = addon.config_vars || [];
+                for (const configVar of configVars) {
+                    const cfgName = configVar.toUpperCase();
+                    if (filter && cfgName.includes(filter)) {
+                        return true;
+                    }
+                }
+                if (addon.name && filter && addon.name.toUpperCase().includes(filter)) {
+                    return true;
+                }
+                return false;
+            }
+            function onResponse(addons) {
+                var _a;
+                const redisAddons = [];
+                for (const addon of addons) {
+                    const service = (_a = addon === null || addon === void 0 ? void 0 : addon.addon_service) === null || _a === void 0 ? void 0 : _a.name;
+                    if (service && service.indexOf(ADDON) === 0 && (!filter || matches(addon))) {
+                        redisAddons.push(addon);
+                    }
+                }
+                return redisAddons;
+            }
+            return onResponse;
+        },
+        async getRedisAddon(addons) {
+            if (!addons) {
+                ({ body: addons } = await heroku.get(`/apps/${app}/addons`));
+            }
+            const addonsFilter = this.makeAddonsFilter(database);
+            const redisAddons = addonsFilter(addons);
+            if (redisAddons.length === 0) {
+                core_1.ux.error('No Redis instances found.', { exit: 1 });
+            }
+            else if (redisAddons.length > 1) {
+                const names = redisAddons.map(function (addon) {
+                    return addon.name;
+                });
+                core_1.ux.error(`Please specify a single instance. Found: ${names.join(', ')}`, { exit: 1 });
+            }
+            return redisAddons[0];
+        },
+        async info() {
+            let { body: addons } = await heroku.get(`/apps/${app}/addons`);
+            // filter out non-redis addons
+            addons = this.makeAddonsFilter(database)(addons);
+            // get info for each db
+            const databases = addons.map(addon => {
+                return {
+                    addon: addon,
+                    redis: this.request(`/redis/v0/databases/${addon.name}`).catch(function (error) {
+                        if (error.statusCode !== 404) {
+                            throw error;
+                        }
+                        return null;
+                    }),
+                };
+            });
+            if (json) {
+                const redii = [];
+                for (const db of databases) {
+                    const { body: redis } = await db.redis || {};
+                    if (!redis) {
+                        continue;
+                    }
+                    const json_data = redis;
+                    json_data.app = db.addon.app;
+                    json_data.config_vars = db.addon.config_vars;
+                    const { formation, metaas_source, port } = json_data, filteredRedis = tslib_1.__rest(json_data, ["formation", "metaas_source", "port"]);
+                    redii.push(filteredRedis);
+                }
+                core_1.ux.styledJSON(redii);
+                return;
+            }
+            // print out the info of the addon and redis db info
+            for (const db of databases) {
+                const { body: redis } = await db.redis || {};
+                if (!redis) {
+                    continue;
+                }
+                let uxHeader = db.addon.name;
+                if (db.addon && db.addon.config_vars) {
+                    uxHeader += ` (${db.addon.config_vars.join(', ')})`;
+                }
+                if (uxHeader) {
+                    core_1.ux.styledHeader(uxHeader);
+                    core_1.ux.styledObject(
+                    // eslint-disable-next-line unicorn/no-array-reduce
+                    redis.info.reduce(function (memo, row) {
+                        memo[row.name] = row.values;
+                        return memo;
+                    }, {}), redis.info.map(row => row.name));
+                }
+            }
+        },
+    };
+};

package/lib/lib/releases/output.d.ts

@@ -0,0 +1 @@
+export declare const stream: (url: string) => Promise<unknown>;

package/lib/lib/releases/output.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stream = void 0;
+const got_1 = require("got");
+const stream = function (url) {
+    return new Promise(function (resolve, reject) {
+        const stream = got_1.default.stream(url);
+        stream.on('error', reject);
+        stream.on('end', resolve);
+        const piped = stream.pipe(process.stdout);
+        piped.on('error', reject);
+    });
+};
+exports.stream = stream;

package/lib/lib/releases/releases.d.ts

@@ -0,0 +1,6 @@
+import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export declare const findRelease: (heroku: APIClient, app: string, search: (releases: Heroku.Release[]) => Heroku.Release) => Promise<Heroku.Release>;
+export declare const getRelease: (heroku: APIClient, app: string, release: string) => Promise<Heroku.Release>;
+export declare const findByLatestOrId: (heroku: APIClient, app: string, release?: string) => Promise<Heroku.Release>;
+export declare const findByPreviousOrId: (heroku: APIClient, app: string, release?: string) => Promise<Heroku.Release>;

package/lib/lib/releases/releases.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findByPreviousOrId = exports.findByLatestOrId = exports.getRelease = exports.findRelease = void 0;
+const findRelease = async function (heroku, app, search) {
+    const { body: releases } = await heroku.request(`/apps/${app}/releases`, {
+        partial: true,
+        headers: { Range: 'version ..; max=10, order=desc' },
+    });
+    return search(releases);
+};
+exports.findRelease = findRelease;
+const getRelease = async function (heroku, app, release) {
+    let id = release.toLowerCase();
+    id = id.startsWith('v') ? id.slice(1) : id;
+    const { body: releaseResponse } = await heroku.get(`/apps/${app}/releases/${id}`);
+    return releaseResponse;
+};
+exports.getRelease = getRelease;
+const findByLatestOrId = async function (heroku, app, release = 'current') {
+    if (release === 'current') {
+        return (0, exports.findRelease)(heroku, app, releases => releases[0]);
+    }
+    return (0, exports.getRelease)(heroku, app, release);
+};
+exports.findByLatestOrId = findByLatestOrId;
+const findByPreviousOrId = async function (heroku, app, release = 'previous') {
+    if (release === 'previous') {
+        return (0, exports.findRelease)(heroku, app, releases => releases.filter(r => r.status === 'succeeded')[1]);
+    }
+    return (0, exports.getRelease)(heroku, app, release);
+};
+exports.findByPreviousOrId = findByPreviousOrId;

package/lib/lib/releases/status_helper.d.ts

@@ -0,0 +1,5 @@
+export declare const description: (release: {
+    [k: string]: any;
+    status?: string | undefined;
+}) => "" | "release command executing" | "release command failed";
+export declare const color: (s?: string) => "red" | "yellow" | "white";

package/lib/lib/releases/status_helper.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.color = exports.description = void 0;
+const description = function (release) {
+    switch (release.status) {
+        case 'pending':
+            return 'release command executing';
+        case 'failed':
+            return 'release command failed';
+        default:
+            return '';
+    }
+};
+exports.description = description;
+const color = function (s) {
+    switch (s) {
+        case 'pending':
+            return 'yellow';
+        case 'failed':
+            return 'red';
+        default:
+            return 'white';
+    }
+};
+exports.color = color;

package/lib/lib/run/dyno.js

@@ -238,7 +238,7 @@ class Dyno extends stream_1.Duplex {
             // @ts-ignore
             sshProc.stderr.on('data', data => {
                 lastErr = data;
-                // supress host key and permission denied messages
+                // suppress host key and permission denied messages
                 if (this._isDebug() || (data.includes("Warning: Permanently added '[127.0.0.1]") && data.includes('Permission denied (publickey).'))) {
                     process.stderr.write(data);
                 }
@@ -336,7 +336,7 @@ class Dyno extends stream_1.Duplex {
             stdin.pipe(c);
             let sigints = [];
             stdin.on('data', function (c) {
-                if (c === '\u0003') {
+                if (c.toString() === '\u0003') {
                     sigints.push(Date.now());
                 }
                 sigints = sigints.filter(d => d > Date.now() - 1000);

package/lib/lib/run/log-displayer.d.ts

@@ -1,7 +1,7 @@
 import { APIClient } from '@heroku-cli/command';
 interface LogDisplayerOptions {
     app: string;
-    dyno: string;
+    dyno?: string;
     lines?: number;
     tail: boolean;
     source?: string;

package/lib/lib/spaces/format.d.ts

@@ -0,0 +1,4 @@
+export declare function displayCIDR(cidr: string[] | undefined): string;
+export declare function hostStatus(s: string): string;
+export declare function peeringStatus(s: string): string;
+export declare function displayVPNStatus(s: string | undefined): string | undefined;

package/lib/lib/spaces/format.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayVPNStatus = exports.peeringStatus = exports.hostStatus = exports.displayCIDR = void 0;
+const color_1 = require("@heroku-cli/color");
+function displayCIDR(cidr) {
+    var _a;
+    return (_a = cidr === null || cidr === void 0 ? void 0 : cidr.join(', ')) !== null && _a !== void 0 ? _a : '';
+}
+exports.displayCIDR = displayCIDR;
+function hostStatus(s) {
+    switch (s) {
+        case 'available':
+            return `${color_1.default.green(s)}`;
+        case 'under-assessment':
+            return `${color_1.default.yellow(s)}`;
+        case 'permanent-failure':
+        case 'released-permanent-failure':
+            return `${color_1.default.red(s)}`;
+        case 'released':
+            return `${color_1.default.gray(s)}`;
+        default:
+            return s;
+    }
+}
+exports.hostStatus = hostStatus;
+function peeringStatus(s) {
+    switch (s) {
+        case 'active':
+            return `${color_1.default.green(s)}`;
+        case 'pending-acceptance':
+        case 'provisioning':
+            return `${color_1.default.yellow(s)}`;
+        case 'expired':
+        case 'failed':
+        case 'deleted':
+        case 'rejected':
+            return `${color_1.default.red(s)}`;
+        default:
+            return s;
+    }
+}
+exports.peeringStatus = peeringStatus;
+function displayVPNStatus(s) {
+    switch (s) {
+        case 'UP':
+        case 'available':
+            return `${color_1.default.green(s)}`;
+        case 'pending':
+        case 'provisioning':
+        case 'deprovisioning':
+            return `${color_1.default.yellow(s)}`;
+        case 'DOWN':
+        case 'deleting':
+        case 'deleted':
+            return `${color_1.default.red(s)}`;
+        default:
+            return s;
+    }
+}
+exports.displayVPNStatus = displayVPNStatus;

package/lib/lib/spaces/hosts.d.ts

@@ -0,0 +1,9 @@
+export declare type Host = {
+    host_id: string;
+    state: string;
+    available_capacity_percentage: number;
+    allocated_at: string;
+    released_at: string;
+};
+export declare function displayHosts(space: string, hosts: Host[]): void;
+export declare function displayHostsAsJSON(hosts: Host[]): void;

package/lib/lib/spaces/hosts.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayHostsAsJSON = exports.displayHosts = void 0;
+const core_1 = require("@oclif/core");
+const format_1 = require("./format");
+function displayHosts(space, hosts) {
+    core_1.ux.styledHeader(`${space} Hosts`);
+    core_1.ux.table(hosts, {
+        host_id: {
+            header: 'Host ID',
+        },
+        state: {
+            header: 'State',
+            get: host => (0, format_1.hostStatus)(host.state),
+        },
+        available_capacity_percentage: {
+            header: 'Available Capacity',
+            get: host => `${host.available_capacity_percentage}%`,
+        },
+        allocated_at: {
+            header: 'Allocated At',
+            get: host => host.allocated_at || '',
+        },
+        released_at: {
+            header: 'Released At',
+            get: host => host.released_at || '',
+        },
+    });
+}
+exports.displayHosts = displayHosts;
+function displayHostsAsJSON(hosts) {
+    core_1.ux.log(JSON.stringify(hosts, null, 2));
+}
+exports.displayHostsAsJSON = displayHostsAsJSON;

package/lib/lib/spaces/outbound-rules.d.ts

@@ -0,0 +1,4 @@
+import * as Heroku from '@heroku-cli/schema';
+export declare function parsePorts(protocol: string, port?: string): number[];
+export declare function displayRules(space: string, ruleset: Heroku.OutboundRuleset): void;
+export declare function displayRulesAsJSON(ruleset: Heroku.OutboundRuleset): void;

package/lib/lib/spaces/outbound-rules.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayRulesAsJSON = exports.displayRules = exports.parsePorts = void 0;
+const core_1 = require("@oclif/core");
+function parsePorts(protocol, port = '') {
+    if (port === '-1' || port === 'any') {
+        if (protocol === 'icmp') {
+            return [0, 255];
+        }
+        return [0, 65535];
+    }
+    let actual = [];
+    const ports = port.split('-').map(port => Number.parseInt(port));
+    if (ports.length === 2) {
+        actual = ports;
+    }
+    else if (ports.length === 1) {
+        actual = ports.concat(ports);
+    }
+    else {
+        throw new Error('Specified --port range seems incorrect.');
+    }
+    if (actual.length !== 2) {
+        throw new Error('Specified --port range seems incorrect.');
+    }
+    return actual;
+}
+exports.parsePorts = parsePorts;
+function displayRules(space, ruleset) {
+    const rules = ruleset.rules || [];
+    if (rules.length > 0) {
+        core_1.ux.styledHeader('Outbound Rules');
+        display(ruleset.rules);
+    }
+    else {
+        core_1.ux.styledHeader(`${space} has no Outbound Rules. Your Dynos cannot communicate with hosts outside of ${space}.`);
+    }
+}
+exports.displayRules = displayRules;
+function displayRulesAsJSON(ruleset) {
+    core_1.ux.log(JSON.stringify(ruleset, null, 2));
+}
+exports.displayRulesAsJSON = displayRulesAsJSON;
+function display(rules) {
+    core_1.ux.table(lined(rules), {
+        line: {
+            header: 'Rule Number',
+        },
+        target: {
+            header: 'Destination',
+        },
+        from_port: {
+            header: 'From Port',
+            get: rule => rule.from_port.toString(),
+        },
+        to_port: {
+            header: 'To Port',
+            get: rule => rule.to_port.toString(),
+        },
+        protocol: {
+            header: 'Protocol',
+        },
+    });
+}
+function lined(rules) {
+    const lined = [];
+    rules = rules || [];
+    for (let i = 0, len = rules.length; i < len; i++) {
+        lined.push({
+            line: i + 1,
+            target: rules[i].target,
+            from_port: rules[i].from_port,
+            to_port: rules[i].to_port,
+            protocol: rules[i].protocol,
+        });
+    }
+    return lined;
+}

package/lib/lib/spaces/parsers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Splits strings separated by commas into an array
+ * If the string is empty or null, an empty array is returned.
+ * @param csvString String with comma-separated values
+ * @returns An array of strings or an empty array
+ *
+ */
+export declare function splitCsv(csvString?: string): string[];

package/lib/lib/spaces/parsers.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitCsv = void 0;
+/**
+ * Splits strings separated by commas into an array
+ * If the string is empty or null, an empty array is returned.
+ * @param csvString String with comma-separated values
+ * @returns An array of strings or an empty array
+ *
+ */
+function splitCsv(csvString) {
+    return (csvString || '')
+        .split(',')
+        .map(s => s.trim())
+        .filter(s => s.length > 0);
+}
+exports.splitCsv = splitCsv;

package/lib/lib/spaces/peering.d.ts

@@ -0,0 +1,4 @@
+import { Peering, PeeringInfo } from '@heroku-cli/schema';
+export declare function displayPeeringInfo(space: string, info: PeeringInfo): void;
+export declare function displayPeeringsAsJSON(peerings: Peering[]): void;
+export declare function displayPeerings(space: string, peerings: Peering[]): void;

package/lib/lib/spaces/peering.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayPeerings = exports.displayPeeringsAsJSON = exports.displayPeeringInfo = void 0;
+const core_1 = require("@oclif/core");
+const format_1 = require("./format");
+function displayPeeringInfo(space, info) {
+    core_1.ux.styledHeader(`${space} Peering Info`);
+    core_1.ux.styledObject({
+        'AWS Account ID': info.aws_account_id,
+        'AWS Region': info.aws_region,
+        'AWS VPC ID': info.vpc_id,
+        'AWS VPC CIDR': info.vpc_cidr,
+        'Space CIDRs': (0, format_1.displayCIDR)(info.space_cidr_blocks),
+        'Unavailable CIDRs': (0, format_1.displayCIDR)(info.unavailable_cidr_blocks),
+    }, ['AWS Account ID', 'AWS Region', 'AWS VPC ID', 'AWS VPC CIDR', 'Space CIDRs', 'Unavailable CIDRs']);
+}
+exports.displayPeeringInfo = displayPeeringInfo;
+function displayPeeringsAsJSON(peerings) {
+    core_1.ux.log(JSON.stringify(peerings, null, 2));
+}
+exports.displayPeeringsAsJSON = displayPeeringsAsJSON;
+function displayPeerings(space, peerings) {
+    core_1.ux.styledHeader(`${space} Peerings`);
+    core_1.ux.table(peerings, {
+        pcx_id: {
+            header: 'PCX ID',
+        },
+        type: {
+            header: 'Type',
+        },
+        cidr_blocks: {
+            header: 'CIDR Blocks',
+            get: (row) => (0, format_1.displayCIDR)(row.cidr_blocks),
+        },
+        status: {
+            header: 'Status',
+            get: (row) => (0, format_1.peeringStatus)(row.status),
+        },
+        aws_vpc_id: {
+            header: 'VPC ID',
+        },
+        aws_region: {
+            header: 'AWS Region',
+        },
+        aws_account_id: {
+            header: 'AWS Account ID',
+        },
+        expires: {
+            header: 'Expires',
+        },
+    });
+}
+exports.displayPeerings = displayPeerings;

package/lib/lib/spaces/spaces.d.ts

@@ -0,0 +1,4 @@
+import * as Heroku from '@heroku-cli/schema';
+export declare function displayShieldState(space: Heroku.Space): "on" | "off";
+export declare function displayNat(nat?: Required<Heroku.SpaceNetworkAddressTranslation>): string | undefined;
+export declare function renderInfo(space: Heroku.Space, json: boolean): void;

package/lib/lib/spaces/spaces.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderInfo = exports.displayNat = exports.displayShieldState = void 0;
+const core_1 = require("@oclif/core");
+function displayShieldState(space) {
+    return space.shield ? 'on' : 'off';
+}
+exports.displayShieldState = displayShieldState;
+function displayNat(nat) {
+    if (!nat)
+        return;
+    if (nat.state !== 'enabled')
+        return nat.state;
+    return nat.sources.join(', ');
+}
+exports.displayNat = displayNat;
+function renderInfo(space, json) {
+    var _a, _b;
+    if (json) {
+        core_1.ux.log(JSON.stringify(space, null, 2));
+    }
+    else {
+        core_1.ux.styledHeader(space.name || '');
+        core_1.ux.styledObject({
+            ID: space.id,
+            Team: (_a = space.team) === null || _a === void 0 ? void 0 : _a.name,
+            Region: (_b = space.region) === null || _b === void 0 ? void 0 : _b.description,
+            CIDR: space.cidr,
+            'Data CIDR': space.data_cidr,
+            State: space.state,
+            Shield: displayShieldState(space),
+            'Outbound IPs': displayNat(space.outbound_ips),
+            'Created at': space.created_at,
+        }, ['ID', 'Team', 'Region', 'CIDR', 'Data CIDR', 'State', 'Shield', 'Outbound IPs', 'Created at']);
+    }
+}
+exports.renderInfo = renderInfo;

package/lib/lib/spaces/vpn-connections.d.ts

@@ -0,0 +1,2 @@
+import { PrivateSpacesVpn } from '@heroku-cli/schema';
+export declare function displayVPNConfigInfo(space: string, name: string, config: PrivateSpacesVpn): void;

package/lib/lib/spaces/vpn-connections.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayVPNConfigInfo = void 0;
+const core_1 = require("@oclif/core");
+function displayVPNConfigInfo(space, name, config) {
+    core_1.ux.styledHeader(`${name} VPN Tunnels`);
+    const configTunnels = config.tunnels || [];
+    configTunnels.forEach((val, i) => {
+        val.tunnel_id = 'Tunnel ' + (i + 1);
+        val.routable_cidr = config.space_cidr_block;
+        val.ike_version = config.ike_version;
+    });
+    core_1.ux.table(configTunnels, {
+        tunnel_id: { header: 'VPN Tunnel' },
+        customer_ip: { header: 'Customer Gateway' },
+        ip: { header: 'VPN Gateway' },
+        pre_shared_key: { header: 'Pre-shared Key' },
+        routable_cidr: { header: 'Routable Subnets' },
+        ike_version: { header: 'IKE Version' },
+    });
+}
+exports.displayVPNConfigInfo = displayVPNConfigInfo;

package/lib/lib/teamUtils.d.ts

@@ -0,0 +1,3 @@
+export declare const isTeamApp: (owner: string | undefined) => boolean;
+export declare const getOwner: (owner: string | undefined) => string | undefined;
+export declare const isValidEmail: (email: string) => boolean;