@aws-cdk/toolkit-lib 0.3.2 → 0.3.4

package/lib/context-providers/load-balancers.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadBalancerListenerContextProviderPlugin = exports.LoadBalancerContextProviderPlugin = void 0;
+const cx_api_1 = require("@aws-cdk/cx-api");
+const private_1 = require("../api/aws-auth/private");
+const toolkit_error_1 = require("../toolkit/toolkit-error");
+/**
+ * Provides load balancer context information.
+ */
+class LoadBalancerContextProviderPlugin {
+    aws;
+    constructor(aws) {
+        this.aws = aws;
+    }
+    async getValue(query) {
+        if (!query.loadBalancerArn && !query.loadBalancerTags) {
+            throw new toolkit_error_1.ContextProviderError('The load balancer lookup query must specify either `loadBalancerArn` or `loadBalancerTags`');
+        }
+        const loadBalancer = await (await LoadBalancerProvider.getClient(this.aws, query)).getLoadBalancer();
+        const ipAddressType = loadBalancer.IpAddressType === 'ipv4' ? cx_api_1.LoadBalancerIpAddressType.IPV4 : cx_api_1.LoadBalancerIpAddressType.DUAL_STACK;
+        return {
+            loadBalancerArn: loadBalancer.LoadBalancerArn,
+            loadBalancerCanonicalHostedZoneId: loadBalancer.CanonicalHostedZoneId,
+            loadBalancerDnsName: loadBalancer.DNSName,
+            vpcId: loadBalancer.VpcId,
+            securityGroupIds: loadBalancer.SecurityGroups ?? [],
+            ipAddressType: ipAddressType,
+        };
+    }
+}
+exports.LoadBalancerContextProviderPlugin = LoadBalancerContextProviderPlugin;
+/**
+ * Provides load balancer listener context information
+ */
+class LoadBalancerListenerContextProviderPlugin {
+    aws;
+    constructor(aws) {
+        this.aws = aws;
+    }
+    async getValue(query) {
+        if (!query.listenerArn && !query.loadBalancerArn && !query.loadBalancerTags) {
+            throw new toolkit_error_1.ContextProviderError('The load balancer listener query must specify at least one of: `listenerArn`, `loadBalancerArn` or `loadBalancerTags`');
+        }
+        return (await LoadBalancerProvider.getClient(this.aws, query)).getListener();
+    }
+}
+exports.LoadBalancerListenerContextProviderPlugin = LoadBalancerListenerContextProviderPlugin;
+class LoadBalancerProvider {
+    client;
+    filter;
+    listener;
+    static async getClient(aws, query) {
+        const client = (await (0, private_1.initContextProviderSdk)(aws, query)).elbv2();
+        try {
+            const listener = query.listenerArn
+                ? // Assert we're sure there's at least one so it throws if not
+                    (await client.describeListeners({ ListenerArns: [query.listenerArn] })).Listeners[0]
+                : undefined;
+            return new LoadBalancerProvider(client, { ...query, loadBalancerArn: listener?.LoadBalancerArn || query.loadBalancerArn }, listener);
+        }
+        catch (err) {
+            throw new toolkit_error_1.ContextProviderError(`No load balancer listeners found matching arn ${query.listenerArn}`);
+        }
+    }
+    constructor(client, filter, listener) {
+        this.client = client;
+        this.filter = filter;
+        this.listener = listener;
+    }
+    async getLoadBalancer() {
+        const loadBalancers = await this.getLoadBalancers();
+        if (loadBalancers.length === 0) {
+            throw new toolkit_error_1.ContextProviderError(`No load balancers found matching ${JSON.stringify(this.filter)}`);
+        }
+        if (loadBalancers.length > 1) {
+            throw new toolkit_error_1.ContextProviderError(`Multiple load balancers found matching ${JSON.stringify(this.filter)} - please provide more specific criteria`);
+        }
+        return loadBalancers[0];
+    }
+    async getListener() {
+        if (this.listener) {
+            try {
+                const loadBalancer = await this.getLoadBalancer();
+                return {
+                    listenerArn: this.listener.ListenerArn,
+                    listenerPort: this.listener.Port,
+                    securityGroupIds: loadBalancer.SecurityGroups || [],
+                };
+            }
+            catch (err) {
+                throw new toolkit_error_1.ContextProviderError(`No associated load balancer found for listener arn ${this.filter.listenerArn}`);
+            }
+        }
+        const loadBalancers = await this.getLoadBalancers();
+        if (loadBalancers.length === 0) {
+            throw new toolkit_error_1.ContextProviderError(`No associated load balancers found for load balancer listener query ${JSON.stringify(this.filter)}`);
+        }
+        const listeners = (await this.getListenersForLoadBalancers(loadBalancers)).filter((listener) => {
+            return ((!this.filter.listenerPort || listener.Port === this.filter.listenerPort) &&
+                (!this.filter.listenerProtocol || listener.Protocol === this.filter.listenerProtocol));
+        });
+        if (listeners.length === 0) {
+            throw new toolkit_error_1.ContextProviderError(`No load balancer listeners found matching ${JSON.stringify(this.filter)}`);
+        }
+        if (listeners.length > 1) {
+            throw new toolkit_error_1.ContextProviderError(`Multiple load balancer listeners found matching ${JSON.stringify(this.filter)} - please provide more specific criteria`);
+        }
+        return {
+            listenerArn: listeners[0].ListenerArn,
+            listenerPort: listeners[0].Port,
+            securityGroupIds: loadBalancers.find((lb) => listeners[0].LoadBalancerArn === lb.LoadBalancerArn)?.SecurityGroups || [],
+        };
+    }
+    async getLoadBalancers() {
+        const loadBalancerArns = this.filter.loadBalancerArn ? [this.filter.loadBalancerArn] : undefined;
+        const loadBalancers = (await this.client.paginateDescribeLoadBalancers({
+            LoadBalancerArns: loadBalancerArns,
+        })).filter((lb) => lb.Type === this.filter.loadBalancerType);
+        return this.filterByTags(loadBalancers);
+    }
+    async filterByTags(loadBalancers) {
+        if (!this.filter.loadBalancerTags) {
+            return loadBalancers;
+        }
+        return (await this.describeTags(loadBalancers.map((lb) => lb.LoadBalancerArn)))
+            .filter((tagDescription) => {
+            // For every tag in the filter, there is some tag in the LB that matches it.
+            // In other words, the set of tags in the filter is a subset of the set of tags in the LB.
+            return this.filter.loadBalancerTags.every((filter) => {
+                return tagDescription.Tags?.some((tag) => filter.key === tag.Key && filter.value === tag.Value);
+            });
+        })
+            .flatMap((tag) => loadBalancers.filter((loadBalancer) => tag.ResourceArn === loadBalancer.LoadBalancerArn));
+    }
+    /**
+     * Returns tag descriptions associated with the resources. The API doesn't support
+     * pagination, so this function breaks the resource list into chunks and issues
+     * the appropriate requests.
+     */
+    async describeTags(resourceArns) {
+        // Max of 20 resource arns per request.
+        const chunkSize = 20;
+        const tags = Array();
+        for (let i = 0; i < resourceArns.length; i += chunkSize) {
+            const chunk = resourceArns.slice(i, Math.min(i + chunkSize, resourceArns.length));
+            const chunkTags = await this.client.describeTags({
+                ResourceArns: chunk,
+            });
+            tags.push(...(chunkTags.TagDescriptions || []));
+        }
+        return tags;
+    }
+    async getListenersForLoadBalancers(loadBalancers) {
+        const listeners = [];
+        for (const loadBalancer of loadBalancers.map((lb) => lb.LoadBalancerArn)) {
+            listeners.push(...(await this.client.paginateDescribeListeners({ LoadBalancerArn: loadBalancer })));
+        }
+        return listeners;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load-balancers.js","sourceRoot":"","sources":["load-balancers.ts"],"names":[],"mappings":"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","sourcesContent":["import type { LoadBalancerContextQuery, LoadBalancerListenerContextQuery } from '@aws-cdk/cloud-assembly-schema';\nimport type {\n  LoadBalancerContextResponse,\n  LoadBalancerListenerContextResponse,\n} from '@aws-cdk/cx-api';\nimport {\n  LoadBalancerIpAddressType,\n} from '@aws-cdk/cx-api';\nimport type { LoadBalancer, Listener, TagDescription } from '@aws-sdk/client-elastic-load-balancing-v2';\nimport type { IElasticLoadBalancingV2Client, SdkProvider } from '../api/aws-auth/private';\nimport { initContextProviderSdk } from '../api/aws-auth/private';\nimport type { ContextProviderPlugin } from '../api/plugin';\nimport { ContextProviderError } from '../toolkit/toolkit-error';\n\n/**\n * Provides load balancer context information.\n */\nexport class LoadBalancerContextProviderPlugin implements ContextProviderPlugin {\n  constructor(private readonly aws: SdkProvider) {\n  }\n\n  async getValue(query: LoadBalancerContextQuery): Promise<LoadBalancerContextResponse> {\n    if (!query.loadBalancerArn && !query.loadBalancerTags) {\n      throw new ContextProviderError('The load balancer lookup query must specify either `loadBalancerArn` or `loadBalancerTags`');\n    }\n\n    const loadBalancer = await (await LoadBalancerProvider.getClient(this.aws, query)).getLoadBalancer();\n\n    const ipAddressType =\n      loadBalancer.IpAddressType === 'ipv4' ? LoadBalancerIpAddressType.IPV4 : LoadBalancerIpAddressType.DUAL_STACK;\n\n    return {\n      loadBalancerArn: loadBalancer.LoadBalancerArn!,\n      loadBalancerCanonicalHostedZoneId: loadBalancer.CanonicalHostedZoneId!,\n      loadBalancerDnsName: loadBalancer.DNSName!,\n      vpcId: loadBalancer.VpcId!,\n      securityGroupIds: loadBalancer.SecurityGroups ?? [],\n      ipAddressType: ipAddressType,\n    };\n  }\n}\n\n/**\n * Provides load balancer listener context information\n */\nexport class LoadBalancerListenerContextProviderPlugin implements ContextProviderPlugin {\n  constructor(private readonly aws: SdkProvider) {\n  }\n\n  async getValue(query: LoadBalancerListenerContextQuery): Promise<LoadBalancerListenerContextResponse> {\n    if (!query.listenerArn && !query.loadBalancerArn && !query.loadBalancerTags) {\n      throw new ContextProviderError(\n        'The load balancer listener query must specify at least one of: `listenerArn`, `loadBalancerArn` or `loadBalancerTags`',\n      );\n    }\n\n    return (await LoadBalancerProvider.getClient(this.aws, query)).getListener();\n  }\n}\n\nclass LoadBalancerProvider {\n  public static async getClient(\n    aws: SdkProvider,\n    query: LoadBalancerListenerContextQuery,\n  ): Promise<LoadBalancerProvider> {\n    const client = (await initContextProviderSdk(aws, query)).elbv2();\n\n    try {\n      const listener = query.listenerArn\n        ? // Assert we're sure there's at least one so it throws if not\n        (await client.describeListeners({ ListenerArns: [query.listenerArn] })).Listeners![0]!\n        : undefined;\n      return new LoadBalancerProvider(\n        client,\n        { ...query, loadBalancerArn: listener?.LoadBalancerArn || query.loadBalancerArn },\n        listener,\n      );\n    } catch (err) {\n      throw new ContextProviderError(`No load balancer listeners found matching arn ${query.listenerArn}`);\n    }\n  }\n\n  constructor(\n    private readonly client: IElasticLoadBalancingV2Client,\n    private readonly filter: LoadBalancerListenerContextQuery,\n    private readonly listener?: Listener,\n  ) {\n  }\n\n  public async getLoadBalancer(): Promise<LoadBalancer> {\n    const loadBalancers = await this.getLoadBalancers();\n\n    if (loadBalancers.length === 0) {\n      throw new ContextProviderError(`No load balancers found matching ${JSON.stringify(this.filter)}`);\n    }\n\n    if (loadBalancers.length > 1) {\n      throw new ContextProviderError(\n        `Multiple load balancers found matching ${JSON.stringify(this.filter)} - please provide more specific criteria`,\n      );\n    }\n\n    return loadBalancers[0];\n  }\n\n  public async getListener(): Promise<LoadBalancerListenerContextResponse> {\n    if (this.listener) {\n      try {\n        const loadBalancer = await this.getLoadBalancer();\n        return {\n          listenerArn: this.listener.ListenerArn!,\n          listenerPort: this.listener.Port!,\n          securityGroupIds: loadBalancer.SecurityGroups || [],\n        };\n      } catch (err) {\n        throw new ContextProviderError(`No associated load balancer found for listener arn ${this.filter.listenerArn}`);\n      }\n    }\n\n    const loadBalancers = await this.getLoadBalancers();\n    if (loadBalancers.length === 0) {\n      throw new ContextProviderError(\n        `No associated load balancers found for load balancer listener query ${JSON.stringify(this.filter)}`,\n      );\n    }\n\n    const listeners = (await this.getListenersForLoadBalancers(loadBalancers)).filter((listener) => {\n      return (\n        (!this.filter.listenerPort || listener.Port === this.filter.listenerPort) &&\n        (!this.filter.listenerProtocol || listener.Protocol === this.filter.listenerProtocol)\n      );\n    });\n\n    if (listeners.length === 0) {\n      throw new ContextProviderError(`No load balancer listeners found matching ${JSON.stringify(this.filter)}`);\n    }\n\n    if (listeners.length > 1) {\n      throw new ContextProviderError(\n        `Multiple load balancer listeners found matching ${JSON.stringify(this.filter)} - please provide more specific criteria`,\n      );\n    }\n\n    return {\n      listenerArn: listeners[0].ListenerArn!,\n      listenerPort: listeners[0].Port!,\n      securityGroupIds:\n        loadBalancers.find((lb) => listeners[0].LoadBalancerArn === lb.LoadBalancerArn)?.SecurityGroups || [],\n    };\n  }\n\n  private async getLoadBalancers() {\n    const loadBalancerArns = this.filter.loadBalancerArn ? [this.filter.loadBalancerArn] : undefined;\n    const loadBalancers = (\n      await this.client.paginateDescribeLoadBalancers({\n        LoadBalancerArns: loadBalancerArns,\n      })\n    ).filter((lb) => lb.Type === this.filter.loadBalancerType);\n\n    return this.filterByTags(loadBalancers);\n  }\n\n  private async filterByTags(loadBalancers: LoadBalancer[]): Promise<LoadBalancer[]> {\n    if (!this.filter.loadBalancerTags) {\n      return loadBalancers;\n    }\n    return (await this.describeTags(loadBalancers.map((lb) => lb.LoadBalancerArn!)))\n      .filter((tagDescription) => {\n        // For every tag in the filter, there is some tag in the LB that matches it.\n        // In other words, the set of tags in the filter is a subset of the set of tags in the LB.\n        return this.filter.loadBalancerTags!.every((filter) => {\n          return tagDescription.Tags?.some((tag) =>\n            filter.key === tag.Key && filter.value === tag.Value);\n        });\n      })\n      .flatMap((tag) => loadBalancers.filter((loadBalancer) => tag.ResourceArn === loadBalancer.LoadBalancerArn));\n  }\n\n  /**\n   * Returns tag descriptions associated with the resources. The API doesn't support\n   * pagination, so this function breaks the resource list into chunks and issues\n   * the appropriate requests.\n   */\n  private async describeTags(resourceArns: string[]): Promise<TagDescription[]> {\n    // Max of 20 resource arns per request.\n    const chunkSize = 20;\n    const tags = Array<TagDescription>();\n    for (let i = 0; i < resourceArns.length; i += chunkSize) {\n      const chunk = resourceArns.slice(i, Math.min(i + chunkSize, resourceArns.length));\n      const chunkTags = await this.client.describeTags({\n        ResourceArns: chunk,\n      });\n\n      tags.push(...(chunkTags.TagDescriptions || []));\n    }\n    return tags;\n  }\n\n  private async getListenersForLoadBalancers(loadBalancers: LoadBalancer[]): Promise<Listener[]> {\n    const listeners: Listener[] = [];\n    for (const loadBalancer of loadBalancers.map((lb) => lb.LoadBalancerArn)) {\n      listeners.push(...(await this.client.paginateDescribeListeners({ LoadBalancerArn: loadBalancer })));\n    }\n    return listeners;\n  }\n}\n"]}

package/lib/context-providers/security-groups.d.ts

@@ -0,0 +1,9 @@
+import type { SecurityGroupContextQuery } from '@aws-cdk/cloud-assembly-schema';
+import type { SecurityGroupContextResponse } from '@aws-cdk/cx-api';
+import { type SdkProvider } from '../api/aws-auth/private';
+import type { ContextProviderPlugin } from '../api/plugin';
+export declare class SecurityGroupContextProviderPlugin implements ContextProviderPlugin {
+    private readonly aws;
+    constructor(aws: SdkProvider);
+    getValue(args: SecurityGroupContextQuery): Promise<SecurityGroupContextResponse>;
+}

package/lib/context-providers/security-groups.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityGroupContextProviderPlugin = void 0;
+exports.hasAllTrafficEgress = hasAllTrafficEgress;
+const private_1 = require("../api/aws-auth/private");
+const toolkit_error_1 = require("../toolkit/toolkit-error");
+class SecurityGroupContextProviderPlugin {
+    aws;
+    constructor(aws) {
+        this.aws = aws;
+    }
+    async getValue(args) {
+        if (args.securityGroupId && args.securityGroupName) {
+            throw new toolkit_error_1.ContextProviderError("'securityGroupId' and 'securityGroupName' can not be specified both when looking up a security group");
+        }
+        if (!args.securityGroupId && !args.securityGroupName) {
+            throw new toolkit_error_1.ContextProviderError("'securityGroupId' or 'securityGroupName' must be specified to look up a security group");
+        }
+        const ec2 = (await (0, private_1.initContextProviderSdk)(this.aws, args)).ec2();
+        const filters = [];
+        if (args.vpcId) {
+            filters.push({
+                Name: 'vpc-id',
+                Values: [args.vpcId],
+            });
+        }
+        if (args.securityGroupName) {
+            filters.push({
+                Name: 'group-name',
+                Values: [args.securityGroupName],
+            });
+        }
+        const response = await ec2.describeSecurityGroups({
+            GroupIds: args.securityGroupId ? [args.securityGroupId] : undefined,
+            Filters: filters.length > 0 ? filters : undefined,
+        });
+        const securityGroups = response.SecurityGroups ?? [];
+        if (securityGroups.length === 0) {
+            throw new toolkit_error_1.ContextProviderError(`No security groups found matching ${JSON.stringify(args)}`);
+        }
+        if (securityGroups.length > 1) {
+            throw new toolkit_error_1.ContextProviderError(`More than one security groups found matching ${JSON.stringify(args)}`);
+        }
+        const [securityGroup] = securityGroups;
+        return {
+            securityGroupId: securityGroup.GroupId,
+            allowAllOutbound: hasAllTrafficEgress(securityGroup),
+        };
+    }
+}
+exports.SecurityGroupContextProviderPlugin = SecurityGroupContextProviderPlugin;
+/**
+ * @internal
+ */
+function hasAllTrafficEgress(securityGroup) {
+    let hasAllTrafficCidrV4 = false;
+    let hasAllTrafficCidrV6 = false;
+    for (const ipPermission of securityGroup.IpPermissionsEgress ?? []) {
+        const isAllProtocols = ipPermission.IpProtocol === '-1';
+        if (isAllProtocols && ipPermission.IpRanges?.some((m) => m.CidrIp === '0.0.0.0/0')) {
+            hasAllTrafficCidrV4 = true;
+        }
+        if (isAllProtocols && ipPermission.Ipv6Ranges?.some((m) => m.CidrIpv6 === '::/0')) {
+            hasAllTrafficCidrV6 = true;
+        }
+    }
+    return hasAllTrafficCidrV4 && hasAllTrafficCidrV6;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/context-providers/ssm-parameters.d.ts

@@ -0,0 +1,25 @@
+import type { SSMParameterContextQuery } from '@aws-cdk/cloud-assembly-schema';
+import type { IContextProviderMessages } from '.';
+import { type SdkProvider } from '../api/aws-auth/private';
+import type { ContextProviderPlugin } from '../api/plugin';
+/**
+ * Plugin to read arbitrary SSM parameter names
+ */
+export declare class SSMContextProviderPlugin implements ContextProviderPlugin {
+    private readonly aws;
+    private readonly io;
+    constructor(aws: SdkProvider, io: IContextProviderMessages);
+    getValue(args: SSMParameterContextQuery): Promise<unknown>;
+    /**
+     * Gets the value of an SSM Parameter, while not throwin if the parameter does not exist.
+     * @param account       the account in which the SSM Parameter is expected to be.
+     * @param region        the region in which the SSM Parameter is expected to be.
+     * @param parameterName the name of the SSM Parameter
+     * @param lookupRoleArn the ARN of the lookup role.
+     *
+     * @returns the result of the ``GetParameter`` operation.
+     *
+     * @throws Error if a service error (other than ``ParameterNotFound``) occurs.
+     */
+    private getSsmParameterValue;
+}

package/lib/context-providers/ssm-parameters.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSMContextProviderPlugin = void 0;
+const private_1 = require("../api/aws-auth/private");
+const toolkit_error_1 = require("../toolkit/toolkit-error");
+/**
+ * Plugin to read arbitrary SSM parameter names
+ */
+class SSMContextProviderPlugin {
+    aws;
+    io;
+    constructor(aws, io) {
+        this.aws = aws;
+        this.io = io;
+    }
+    async getValue(args) {
+        const region = args.region;
+        const account = args.account;
+        if (!('parameterName' in args)) {
+            throw new toolkit_error_1.ContextProviderError('parameterName must be provided in props for SSMContextProviderPlugin');
+        }
+        const parameterName = args.parameterName;
+        await this.io.debug(`Reading SSM parameter ${account}:${region}:${parameterName}`);
+        const response = await this.getSsmParameterValue(args);
+        const parameterNotFound = !response.Parameter || response.Parameter.Value === undefined;
+        const suppressError = 'ignoreErrorOnMissingContext' in args && args.ignoreErrorOnMissingContext;
+        if (parameterNotFound && suppressError && 'dummyValue' in args) {
+            return args.dummyValue;
+        }
+        if (parameterNotFound) {
+            throw new toolkit_error_1.ContextProviderError(`SSM parameter not available in account ${account}, region ${region}: ${parameterName}`);
+        }
+        // will not be undefined because we've handled undefined cases above
+        return response.Parameter.Value;
+    }
+    /**
+     * Gets the value of an SSM Parameter, while not throwin if the parameter does not exist.
+     * @param account       the account in which the SSM Parameter is expected to be.
+     * @param region        the region in which the SSM Parameter is expected to be.
+     * @param parameterName the name of the SSM Parameter
+     * @param lookupRoleArn the ARN of the lookup role.
+     *
+     * @returns the result of the ``GetParameter`` operation.
+     *
+     * @throws Error if a service error (other than ``ParameterNotFound``) occurs.
+     */
+    async getSsmParameterValue(args) {
+        const ssm = (await (0, private_1.initContextProviderSdk)(this.aws, args)).ssm();
+        try {
+            return await ssm.getParameter({ Name: args.parameterName });
+        }
+        catch (e) {
+            if (e.name === 'ParameterNotFound') {
+                return { $metadata: {} };
+            }
+            throw e;
+        }
+    }
+}
+exports.SSMContextProviderPlugin = SSMContextProviderPlugin;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/context-providers/vpcs.d.ts

@@ -0,0 +1,13 @@
+import type { VpcContextQuery } from '@aws-cdk/cloud-assembly-schema';
+import { type VpcContextResponse } from '@aws-cdk/cx-api';
+import type { IContextProviderMessages } from '.';
+import type { SdkProvider } from '../api/aws-auth/private';
+import type { ContextProviderPlugin } from '../api/plugin';
+export declare class VpcNetworkContextProviderPlugin implements ContextProviderPlugin {
+    private readonly aws;
+    private readonly io;
+    constructor(aws: SdkProvider, io: IContextProviderMessages);
+    getValue(args: VpcContextQuery): Promise<VpcContextResponse>;
+    private findVpc;
+    private readVpcProps;
+}