@gemeentenijmegen/webapp 1.1.12 → 1.1.14

package/node_modules/@aws-solutions-constructs/core/node_modules/@aws-cdk/cloud-assembly-schema/lib/cloud-assembly/context-queries.d.ts

@@ -0,0 +1,462 @@
+import type { Tag } from './metadata-schema';
+/**
+ * Identifier for the context provider
+ */
+export declare enum ContextProvider {
+    /**
+     * AMI provider
+     */
+    AMI_PROVIDER = "ami",
+    /**
+     * AZ provider
+     */
+    AVAILABILITY_ZONE_PROVIDER = "availability-zones",
+    /**
+     * Route53 Hosted Zone provider
+     */
+    HOSTED_ZONE_PROVIDER = "hosted-zone",
+    /**
+     * SSM Parameter Provider
+     */
+    SSM_PARAMETER_PROVIDER = "ssm",
+    /**
+     * VPC Provider
+     */
+    VPC_PROVIDER = "vpc-provider",
+    /**
+     * VPC Endpoint Service AZ Provider
+     */
+    ENDPOINT_SERVICE_AVAILABILITY_ZONE_PROVIDER = "endpoint-service-availability-zones",
+    /**
+     * Load balancer provider
+     */
+    LOAD_BALANCER_PROVIDER = "load-balancer",
+    /**
+     * Load balancer listener provider
+     */
+    LOAD_BALANCER_LISTENER_PROVIDER = "load-balancer-listener",
+    /**
+     * Security group provider
+     */
+    SECURITY_GROUP_PROVIDER = "security-group",
+    /**
+     * KMS Key Provider
+     */
+    KEY_PROVIDER = "key-provider",
+    /**
+     * CCAPI Provider
+     */
+    CC_API_PROVIDER = "cc-api-provider",
+    /**
+     * A plugin provider (the actual plugin name will be in the properties)
+     */
+    PLUGIN = "plugin"
+}
+/**
+ * Options for context lookup roles.
+ */
+export interface ContextLookupRoleOptions {
+    /**
+     * Query account
+     */
+    readonly account: string;
+    /**
+     * Query region
+     */
+    readonly region: string;
+    /**
+     * The ARN of the role that should be used to look up the missing values
+     *
+     * @default - None
+     */
+    readonly lookupRoleArn?: string;
+    /**
+     * The ExternalId that needs to be supplied while assuming this role
+     *
+     * @default - No ExternalId will be supplied
+     */
+    readonly lookupRoleExternalId?: string;
+    /**
+     * Additional options to pass to STS when assuming the lookup role.
+     *
+     * - `RoleArn` should not be used. Use the dedicated `lookupRoleArn` property instead.
+     * - `ExternalId` should not be used. Use the dedicated `lookupRoleExternalId` instead.
+     *
+     * @see https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/STS.html#assumeRole-property
+     * @default - No additional options.
+     */
+    readonly assumeRoleAdditionalOptions?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Query to AMI context provider
+ */
+export interface AmiContextQuery extends ContextLookupRoleOptions {
+    /**
+     * Owners to DescribeImages call
+     *
+     * @default - All owners
+     */
+    readonly owners?: string[];
+    /**
+     * Filters to DescribeImages call
+     */
+    readonly filters: {
+        [key: string]: string[];
+    };
+}
+/**
+ * Query to availability zone context provider
+ */
+export interface AvailabilityZonesContextQuery extends ContextLookupRoleOptions {
+}
+/**
+ * Query to hosted zone context provider
+ */
+export interface HostedZoneContextQuery extends ContextLookupRoleOptions {
+    /**
+     * The domain name e.g. example.com to lookup
+     */
+    readonly domainName: string;
+    /**
+     * True if the zone you want to find is a private hosted zone
+     *
+     * @default false
+     */
+    readonly privateZone?: boolean;
+    /**
+     * The VPC ID to that the private zone must be associated with
+     *
+     * If you provide VPC ID and privateZone is false, this will return no results
+     * and raise an error.
+     *
+     * @default - Required if privateZone=true
+     */
+    readonly vpcId?: string;
+}
+/**
+ * Query to SSM Parameter Context Provider
+ */
+export interface SSMParameterContextQuery extends ContextLookupRoleOptions {
+    /**
+     * Parameter name to query
+     */
+    readonly parameterName: string;
+}
+/**
+ * Query input for looking up a VPC
+ */
+export interface VpcContextQuery extends ContextLookupRoleOptions {
+    /**
+     * Filters to apply to the VPC
+     *
+     * Filter parameters are the same as passed to DescribeVpcs.
+     *
+     * @see https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVpcs.html
+     */
+    readonly filter: {
+        [key: string]: string;
+    };
+    /**
+     * Whether to populate the subnetGroups field of the `VpcContextResponse`,
+     * which contains potentially asymmetric subnet groups.
+     *
+     * @default false
+     */
+    readonly returnAsymmetricSubnets?: boolean;
+    /**
+     * Optional tag for subnet group name.
+     * If not provided, we'll look at the aws-cdk:subnet-name tag.
+     * If the subnet does not have the specified tag,
+     * we'll use its type as the name.
+     *
+     * @default 'aws-cdk:subnet-name'
+     */
+    readonly subnetGroupNameTag?: string;
+    /**
+     * Whether to populate the `vpnGatewayId` field of the `VpcContextResponse`,
+     * which contains the VPN Gateway ID, if one exists. You can explicitly
+     * disable this in order to avoid the lookup if you know the VPC does not have
+     * a VPN Gatway attached.
+     *
+     * @default true
+     */
+    readonly returnVpnGateways?: boolean;
+}
+/**
+ * Query to endpoint service context provider
+ */
+export interface EndpointServiceAvailabilityZonesContextQuery extends ContextLookupRoleOptions {
+    /**
+     * Query service name
+     */
+    readonly serviceName: string;
+}
+/**
+ * Type of load balancer
+ */
+export declare enum LoadBalancerType {
+    /**
+     * Network load balancer
+     */
+    NETWORK = "network",
+    /**
+     * Application load balancer
+     */
+    APPLICATION = "application"
+}
+/**
+ * Filters for selecting load balancers
+ */
+export interface LoadBalancerFilter extends ContextLookupRoleOptions {
+    /**
+     * Filter load balancers by their type
+     */
+    readonly loadBalancerType: LoadBalancerType;
+    /**
+     * Find by load balancer's ARN
+     * @default - does not search by load balancer arn
+     */
+    readonly loadBalancerArn?: string;
+    /**
+     * Match load balancer tags
+     * @default - does not match load balancers by tags
+     */
+    readonly loadBalancerTags?: Tag[];
+}
+/**
+ * Query input for looking up a load balancer
+ */
+export interface LoadBalancerContextQuery extends LoadBalancerFilter {
+}
+/**
+ * The protocol for connections from clients to the load balancer
+ */
+export declare enum LoadBalancerListenerProtocol {
+    /**
+     * HTTP protocol
+     */
+    HTTP = "HTTP",
+    /**
+     * HTTPS protocol
+     */
+    HTTPS = "HTTPS",
+    /**
+     * TCP protocol
+     */
+    TCP = "TCP",
+    /**
+     * TLS protocol
+     */
+    TLS = "TLS",
+    /**
+     * UDP protocol
+     * */
+    UDP = "UDP",
+    /**
+     * TCP and UDP protocol
+     * */
+    TCP_UDP = "TCP_UDP"
+}
+/**
+ * Query input for looking up a load balancer listener
+ */
+export interface LoadBalancerListenerContextQuery extends LoadBalancerFilter {
+    /**
+     * Find by listener's arn
+     * @default - does not find by listener arn
+     */
+    readonly listenerArn?: string;
+    /**
+     * Filter by listener protocol
+     * @default - does not filter by listener protocol
+     */
+    readonly listenerProtocol?: LoadBalancerListenerProtocol;
+    /**
+     * Filter listeners by listener port
+     * @default - does not filter by a listener port
+     */
+    readonly listenerPort?: number;
+}
+/**
+ * Query input for looking up a security group
+ */
+export interface SecurityGroupContextQuery extends ContextLookupRoleOptions {
+    /**
+     * Security group id
+     *
+     * @default - None
+     */
+    readonly securityGroupId?: string;
+    /**
+     * Security group name
+     *
+     * @default - None
+     */
+    readonly securityGroupName?: string;
+    /**
+     * VPC ID
+     *
+     * @default - None
+     */
+    readonly vpcId?: string;
+}
+/**
+ * Query input for looking up a KMS Key
+ */
+export interface KeyContextQuery extends ContextLookupRoleOptions {
+    /**
+     * Alias name used to search the Key
+     */
+    readonly aliasName: string;
+}
+/**
+ * Query input for lookup up CloudFormation resources using CC API
+ *
+ * The example below is required to successfully compile CDK (otherwise,
+ * the CDK build will generate a synthetic example for the below, but it
+ * doesn't have enough type information about the literal string union
+ * to generate a validly compiling example).
+ *
+ * @example
+ * import { CcApiContextQuery } from '@aws-cdk/cloud-assembly-schema';
+ *
+ * const x: CcApiContextQuery = {
+ *   typeName: 'AWS::Some::Type',
+ *   expectedMatchCount: 'exactly-one',
+ *   resourceModel: {SomeArn: 'arn:aws:....'},
+ *   propertiesToReturn: ['SomeProp'],
+ *   account: '11111111111',
+ *   region: 'us-east-1',
+ * };
+ */
+export interface CcApiContextQuery extends ContextLookupRoleOptions {
+    /**
+     * The CloudFormation resource type.
+     * See https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/supported-resources.html
+     */
+    readonly typeName: string;
+    /**
+     * Identifier of the resource to look up using `GetResource`.
+     *
+     * Specifying exactIdentifier will return exactly one result, or throw an error
+     * unless `ignoreErrorOnMissingContext` is set.
+     *
+     * @default - Either exactIdentifier or propertyMatch should be specified.
+     */
+    readonly exactIdentifier?: string;
+    /**
+     * The resource model to use to select the resources, using `ListResources`..
+     *
+     * This is needed for sub-resources where the parent Arn is required.
+     *
+     * See https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/resource-operations-list.html#resource-operations-list-containers
+     *
+     * @default - no resource Model is provided
+     */
+    readonly resourceModel?: Record<string, unknown>;
+    /**
+     * Returns any resources matching these properties, using `ListResources`.
+     *
+     * By default, specifying propertyMatch will successfully return 0 or more
+     * results. To throw an error if the number of results is unexpected (and
+     * prevent the query results from being committed to context), specify
+     * `expectedMatchCount`.
+     *
+     * ## Notes on property completeness
+     *
+     * CloudControl API's `ListResources` may return fewer properties than
+     * `GetResource` would, depending on the resource implementation.
+     *
+     * The resources that `propertyMatch` matches against will *only ever* be the
+     * properties returned by the `ListResources` call.
+     *
+     * @default - Either exactIdentifier or propertyMatch should be specified.
+     */
+    readonly propertyMatch?: Record<string, unknown>;
+    /**
+     * This is a set of properties returned from CC API that we want to return from ContextQuery.
+     *
+     * If any properties listed here are absent from the target resource, an error will be thrown.
+     *
+     * The returned object will always include the key `Identifier` with the CC-API returned
+     * field `Identifier`.
+     *
+     * ## Notes on property completeness
+     *
+     * CloudControl API's `ListResources` may return fewer properties than
+     * `GetResource` would, depending on the resource implementation.
+     *
+     * The returned properties here are *currently* selected from the response
+     * object that CloudControl API returns to the CDK CLI.
+     *
+     * However, if we find there is need to do so, we may decide to change this
+     * behavior in the future: we might change it to perform an additional
+     * `GetResource` call for resources matched by `propertyMatch`.
+     */
+    readonly propertiesToReturn: string[];
+    /**
+     * Expected count of results if `propertyMatch` is specified.
+     *
+     * If the expected result count does not match the actual count,
+     * by default an error is produced and the result is not committed to cached
+     * context, and the user can correct the situation and try again without
+     * having to manually clear out the context key using `cdk context --remove`
+     *
+     * If the value of * `ignoreErrorOnMissingContext` is `true`, the value of
+     * `expectedMatchCount` is `at-least-one | exactly-one` and the number
+     * of found resources is 0, `dummyValue` is returned and committed to context
+     * instead.
+     *
+     * @default 'any'
+     */
+    readonly expectedMatchCount?: 'any' | 'at-least-one' | 'at-most-one' | 'exactly-one';
+    /**
+     * The value to return if the resource was not found and `ignoreErrorOnMissingContext` is true.
+     *
+     * If supplied, `dummyValue` should be an array of objects.
+     *
+     * `dummyValue` does not have to have elements, and it may have objects with
+     * different properties than the properties in `propertiesToReturn`, but it
+     * will be easiest for downstream code if the `dummyValue` conforms to
+     * the expected response shape.
+     *
+     * @default - No dummy value available
+     */
+    readonly dummyValue?: any;
+    /**
+     * Ignore an error and return the `dummyValue` instead if the resource was not found.
+     *
+     * - In case of an `exactIdentifier` lookup, return the `dummyValue` if the resource with
+     *   that identifier was not found.
+     * - In case of a `propertyMatch` lookup, return the `dummyValue` if `expectedMatchCount`
+     *   is `at-least-one | exactly-one` and the number of resources found was 0.
+     *
+     * if `ignoreErrorOnMissingContext` is set, `dummyValue` should be set and be an array.
+     *
+     * @default false
+     */
+    readonly ignoreErrorOnMissingContext?: boolean;
+}
+/**
+ * Query input for plugins
+ *
+ * This alternate branch is necessary because it needs to be able to escape all type checking
+ * we do on on the cloud assembly -- we cannot know the properties that will be used a priori.
+ */
+export interface PluginContextQuery {
+    /**
+     * The name of the plugin
+     */
+    readonly pluginName: string;
+    /**
+     * Arbitrary other arguments for the plugin.
+     *
+     * This index signature is not usable in non-TypeScript/JavaScript languages.
+     *
+     * @jsii ignore
+     */
+    [key: string]: any;
+}
+export type ContextQueryProperties = AmiContextQuery | AvailabilityZonesContextQuery | HostedZoneContextQuery | SSMParameterContextQuery | VpcContextQuery | EndpointServiceAvailabilityZonesContextQuery | LoadBalancerContextQuery | LoadBalancerListenerContextQuery | SecurityGroupContextQuery | KeyContextQuery | CcApiContextQuery | PluginContextQuery;

package/node_modules/@aws-solutions-constructs/core/node_modules/@aws-cdk/cloud-assembly-schema/lib/cloud-assembly/context-queries.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadBalancerListenerProtocol = exports.LoadBalancerType = exports.ContextProvider = void 0;
+/**
+ * Identifier for the context provider
+ */
+var ContextProvider;
+(function (ContextProvider) {
+    /**
+     * AMI provider
+     */
+    ContextProvider["AMI_PROVIDER"] = "ami";
+    /**
+     * AZ provider
+     */
+    ContextProvider["AVAILABILITY_ZONE_PROVIDER"] = "availability-zones";
+    /**
+     * Route53 Hosted Zone provider
+     */
+    ContextProvider["HOSTED_ZONE_PROVIDER"] = "hosted-zone";
+    /**
+     * SSM Parameter Provider
+     */
+    ContextProvider["SSM_PARAMETER_PROVIDER"] = "ssm";
+    /**
+     * VPC Provider
+     */
+    ContextProvider["VPC_PROVIDER"] = "vpc-provider";
+    /**
+     * VPC Endpoint Service AZ Provider
+     */
+    ContextProvider["ENDPOINT_SERVICE_AVAILABILITY_ZONE_PROVIDER"] = "endpoint-service-availability-zones";
+    /**
+     * Load balancer provider
+     */
+    ContextProvider["LOAD_BALANCER_PROVIDER"] = "load-balancer";
+    /**
+     * Load balancer listener provider
+     */
+    ContextProvider["LOAD_BALANCER_LISTENER_PROVIDER"] = "load-balancer-listener";
+    /**
+     * Security group provider
+     */
+    ContextProvider["SECURITY_GROUP_PROVIDER"] = "security-group";
+    /**
+     * KMS Key Provider
+     */
+    ContextProvider["KEY_PROVIDER"] = "key-provider";
+    /**
+     * CCAPI Provider
+     */
+    ContextProvider["CC_API_PROVIDER"] = "cc-api-provider";
+    /**
+     * A plugin provider (the actual plugin name will be in the properties)
+     */
+    ContextProvider["PLUGIN"] = "plugin";
+})(ContextProvider || (exports.ContextProvider = ContextProvider = {}));
+/**
+ * Type of load balancer
+ */
+var LoadBalancerType;
+(function (LoadBalancerType) {
+    /**
+     * Network load balancer
+     */
+    LoadBalancerType["NETWORK"] = "network";
+    /**
+     * Application load balancer
+     */
+    LoadBalancerType["APPLICATION"] = "application";
+})(LoadBalancerType || (exports.LoadBalancerType = LoadBalancerType = {}));
+/**
+ * The protocol for connections from clients to the load balancer
+ */
+var LoadBalancerListenerProtocol;
+(function (LoadBalancerListenerProtocol) {
+    /**
+     * HTTP protocol
+     */
+    LoadBalancerListenerProtocol["HTTP"] = "HTTP";
+    /**
+     * HTTPS protocol
+     */
+    LoadBalancerListenerProtocol["HTTPS"] = "HTTPS";
+    /**
+     * TCP protocol
+     */
+    LoadBalancerListenerProtocol["TCP"] = "TCP";
+    /**
+     * TLS protocol
+     */
+    LoadBalancerListenerProtocol["TLS"] = "TLS";
+    /**
+     * UDP protocol
+     * */
+    LoadBalancerListenerProtocol["UDP"] = "UDP";
+    /**
+     * TCP and UDP protocol
+     * */
+    LoadBalancerListenerProtocol["TCP_UDP"] = "TCP_UDP";
+})(LoadBalancerListenerProtocol || (exports.LoadBalancerListenerProtocol = LoadBalancerListenerProtocol = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-queries.js","sourceRoot":"","sources":["context-queries.ts"],"names":[],"mappings":";;;AAEA;;GAEG;AACH,IAAY,eA4DX;AA5DD,WAAY,eAAe;IACzB;;OAEG;IACH,uCAAoB,CAAA;IAEpB;;OAEG;IACH,oEAAiD,CAAA;IAEjD;;OAEG;IACH,uDAAoC,CAAA;IAEpC;;OAEG;IACH,iDAA8B,CAAA;IAE9B;;OAEG;IACH,gDAA6B,CAAA;IAE7B;;OAEG;IACH,sGAAmF,CAAA;IAEnF;;OAEG;IACH,2DAAwC,CAAA;IAExC;;OAEG;IACH,6EAA0D,CAAA;IAE1D;;OAEG;IACH,6DAA0C,CAAA;IAE1C;;OAEG;IACH,gDAA6B,CAAA;IAE7B;;OAEG;IACH,sDAAmC,CAAA;IAEnC;;OAEG;IACH,oCAAiB,CAAA;AACnB,CAAC,EA5DW,eAAe,+BAAf,eAAe,QA4D1B;AA0JD;;GAEG;AACH,IAAY,gBAUX;AAVD,WAAY,gBAAgB;IAC1B;;OAEG;IACH,uCAAmB,CAAA;IAEnB;;OAEG;IACH,+CAA2B,CAAA;AAC7B,CAAC,EAVW,gBAAgB,gCAAhB,gBAAgB,QAU3B;AA8BD;;GAEG;AACH,IAAY,4BA8BX;AA9BD,WAAY,4BAA4B;IACtC;;OAEG;IACH,6CAAa,CAAA;IAEb;;OAEG;IACH,+CAAe,CAAA;IAEf;;OAEG;IACH,2CAAW,CAAA;IAEX;;OAEG;IACH,2CAAW,CAAA;IAEX;;SAEK;IACL,2CAAW,CAAA;IAEX;;SAEK;IACL,mDAAmB,CAAA;AACrB,CAAC,EA9BW,4BAA4B,4CAA5B,4BAA4B,QA8BvC","sourcesContent":["import type { Tag } from './metadata-schema';\n\n/**\n * Identifier for the context provider\n */\nexport enum ContextProvider {\n  /**\n   * AMI provider\n   */\n  AMI_PROVIDER = 'ami',\n\n  /**\n   * AZ provider\n   */\n  AVAILABILITY_ZONE_PROVIDER = 'availability-zones',\n\n  /**\n   * Route53 Hosted Zone provider\n   */\n  HOSTED_ZONE_PROVIDER = 'hosted-zone',\n\n  /**\n   * SSM Parameter Provider\n   */\n  SSM_PARAMETER_PROVIDER = 'ssm',\n\n  /**\n   * VPC Provider\n   */\n  VPC_PROVIDER = 'vpc-provider',\n\n  /**\n   * VPC Endpoint Service AZ Provider\n   */\n  ENDPOINT_SERVICE_AVAILABILITY_ZONE_PROVIDER = 'endpoint-service-availability-zones',\n\n  /**\n   * Load balancer provider\n   */\n  LOAD_BALANCER_PROVIDER = 'load-balancer',\n\n  /**\n   * Load balancer listener provider\n   */\n  LOAD_BALANCER_LISTENER_PROVIDER = 'load-balancer-listener',\n\n  /**\n   * Security group provider\n   */\n  SECURITY_GROUP_PROVIDER = 'security-group',\n\n  /**\n   * KMS Key Provider\n   */\n  KEY_PROVIDER = 'key-provider',\n\n  /**\n   * CCAPI Provider\n   */\n  CC_API_PROVIDER = 'cc-api-provider',\n\n  /**\n   * A plugin provider (the actual plugin name will be in the properties)\n   */\n  PLUGIN = 'plugin',\n}\n\n/**\n * Options for context lookup roles.\n */\nexport interface ContextLookupRoleOptions {\n  /**\n   * Query account\n   */\n  readonly account: string;\n\n  /**\n   * Query region\n   */\n  readonly region: string;\n\n  /**\n   * The ARN of the role that should be used to look up the missing values\n   *\n   * @default - None\n   */\n  readonly lookupRoleArn?: string;\n\n  /**\n   * The ExternalId that needs to be supplied while assuming this role\n   *\n   * @default - No ExternalId will be supplied\n   */\n  readonly lookupRoleExternalId?: string;\n\n  /**\n   * Additional options to pass to STS when assuming the lookup role.\n   *\n   * - `RoleArn` should not be used. Use the dedicated `lookupRoleArn` property instead.\n   * - `ExternalId` should not be used. Use the dedicated `lookupRoleExternalId` instead.\n   *\n   * @see https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/STS.html#assumeRole-property\n   * @default - No additional options.\n   */\n  readonly assumeRoleAdditionalOptions?: { [key: string]: any };\n}\n\n/**\n * Query to AMI context provider\n */\nexport interface AmiContextQuery extends ContextLookupRoleOptions {\n  /**\n   * Owners to DescribeImages call\n   *\n   * @default - All owners\n   */\n  readonly owners?: string[];\n\n  /**\n   * Filters to DescribeImages call\n   */\n  readonly filters: { [key: string]: string[] };\n}\n\n/**\n * Query to availability zone context provider\n */\nexport interface AvailabilityZonesContextQuery extends ContextLookupRoleOptions {\n}\n\n/**\n * Query to hosted zone context provider\n */\nexport interface HostedZoneContextQuery extends ContextLookupRoleOptions {\n  /**\n   * The domain name e.g. example.com to lookup\n   */\n  readonly domainName: string;\n\n  /**\n   * True if the zone you want to find is a private hosted zone\n   *\n   * @default false\n   */\n  readonly privateZone?: boolean;\n\n  /**\n   * The VPC ID to that the private zone must be associated with\n   *\n   * If you provide VPC ID and privateZone is false, this will return no results\n   * and raise an error.\n   *\n   * @default - Required if privateZone=true\n   */\n  readonly vpcId?: string;\n}\n\n/**\n * Query to SSM Parameter Context Provider\n */\nexport interface SSMParameterContextQuery extends ContextLookupRoleOptions {\n  /**\n   * Parameter name to query\n   */\n  readonly parameterName: string;\n}\n\n/**\n * Query input for looking up a VPC\n */\nexport interface VpcContextQuery extends ContextLookupRoleOptions {\n  /**\n   * Filters to apply to the VPC\n   *\n   * Filter parameters are the same as passed to DescribeVpcs.\n   *\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVpcs.html\n   */\n  readonly filter: { [key: string]: string };\n\n  /**\n   * Whether to populate the subnetGroups field of the `VpcContextResponse`,\n   * which contains potentially asymmetric subnet groups.\n   *\n   * @default false\n   */\n  readonly returnAsymmetricSubnets?: boolean;\n\n  /**\n   * Optional tag for subnet group name.\n   * If not provided, we'll look at the aws-cdk:subnet-name tag.\n   * If the subnet does not have the specified tag,\n   * we'll use its type as the name.\n   *\n   * @default 'aws-cdk:subnet-name'\n   */\n  readonly subnetGroupNameTag?: string;\n\n  /**\n   * Whether to populate the `vpnGatewayId` field of the `VpcContextResponse`,\n   * which contains the VPN Gateway ID, if one exists. You can explicitly\n   * disable this in order to avoid the lookup if you know the VPC does not have\n   * a VPN Gatway attached.\n   *\n   * @default true\n   */\n  readonly returnVpnGateways?: boolean;\n}\n\n/**\n * Query to endpoint service context provider\n */\nexport interface EndpointServiceAvailabilityZonesContextQuery extends ContextLookupRoleOptions {\n  /**\n   * Query service name\n   */\n  readonly serviceName: string;\n}\n\n/**\n * Type of load balancer\n */\nexport enum LoadBalancerType {\n  /**\n   * Network load balancer\n   */\n  NETWORK = 'network',\n\n  /**\n   * Application load balancer\n   */\n  APPLICATION = 'application',\n}\n\n/**\n * Filters for selecting load balancers\n */\nexport interface LoadBalancerFilter extends ContextLookupRoleOptions {\n  /**\n   * Filter load balancers by their type\n   */\n  readonly loadBalancerType: LoadBalancerType;\n\n  /**\n   * Find by load balancer's ARN\n   * @default - does not search by load balancer arn\n   */\n  readonly loadBalancerArn?: string;\n\n  /**\n   * Match load balancer tags\n   * @default - does not match load balancers by tags\n   */\n  readonly loadBalancerTags?: Tag[];\n}\n\n/**\n * Query input for looking up a load balancer\n */\nexport interface LoadBalancerContextQuery extends LoadBalancerFilter {\n}\n\n/**\n * The protocol for connections from clients to the load balancer\n */\nexport enum LoadBalancerListenerProtocol {\n  /**\n   * HTTP protocol\n   */\n  HTTP = 'HTTP',\n\n  /**\n   * HTTPS protocol\n   */\n  HTTPS = 'HTTPS',\n\n  /**\n   * TCP protocol\n   */\n  TCP = 'TCP',\n\n  /**\n   * TLS protocol\n   */\n  TLS = 'TLS',\n\n  /**\n   * UDP protocol\n   * */\n  UDP = 'UDP',\n\n  /**\n   * TCP and UDP protocol\n   * */\n  TCP_UDP = 'TCP_UDP',\n}\n\n/**\n * Query input for looking up a load balancer listener\n */\nexport interface LoadBalancerListenerContextQuery extends LoadBalancerFilter {\n  /**\n   * Find by listener's arn\n   * @default - does not find by listener arn\n   */\n  readonly listenerArn?: string;\n\n  /**\n   * Filter by listener protocol\n   * @default - does not filter by listener protocol\n   */\n  readonly listenerProtocol?: LoadBalancerListenerProtocol;\n\n  /**\n   * Filter listeners by listener port\n   * @default - does not filter by a listener port\n   */\n  readonly listenerPort?: number;\n}\n\n/**\n * Query input for looking up a security group\n */\nexport interface SecurityGroupContextQuery extends ContextLookupRoleOptions {\n  /**\n   * Security group id\n   *\n   * @default - None\n   */\n  readonly securityGroupId?: string;\n\n  /**\n   * Security group name\n   *\n   * @default - None\n   */\n  readonly securityGroupName?: string;\n\n  /**\n   * VPC ID\n   *\n   * @default - None\n   */\n  readonly vpcId?: string;\n}\n\n/**\n * Query input for looking up a KMS Key\n */\nexport interface KeyContextQuery extends ContextLookupRoleOptions {\n  /**\n   * Alias name used to search the Key\n   */\n  readonly aliasName: string;\n}\n\n/**\n * Query input for lookup up CloudFormation resources using CC API\n *\n * The example below is required to successfully compile CDK (otherwise,\n * the CDK build will generate a synthetic example for the below, but it\n * doesn't have enough type information about the literal string union\n * to generate a validly compiling example).\n *\n * @example\n * import { CcApiContextQuery } from '@aws-cdk/cloud-assembly-schema';\n *\n * const x: CcApiContextQuery = {\n *   typeName: 'AWS::Some::Type',\n *   expectedMatchCount: 'exactly-one',\n *   resourceModel: {SomeArn: 'arn:aws:....'},\n *   propertiesToReturn: ['SomeProp'],\n *   account: '11111111111',\n *   region: 'us-east-1',\n * };\n */\nexport interface CcApiContextQuery extends ContextLookupRoleOptions {\n  /**\n   * The CloudFormation resource type.\n   * See https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/supported-resources.html\n   */\n  readonly typeName: string;\n\n  /**\n   * Identifier of the resource to look up using `GetResource`.\n   *\n   * Specifying exactIdentifier will return exactly one result, or throw an error\n   * unless `ignoreErrorOnMissingContext` is set.\n   *\n   * @default - Either exactIdentifier or propertyMatch should be specified.\n   */\n  readonly exactIdentifier?: string;\n\n  /**\n   * The resource model to use to select the resources, using `ListResources`..\n   *\n   * This is needed for sub-resources where the parent Arn is required.\n   *\n   * See https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/resource-operations-list.html#resource-operations-list-containers\n   *\n   * @default - no resource Model is provided\n   */\n  readonly resourceModel?: Record<string, unknown>;\n\n  /**\n   * Returns any resources matching these properties, using `ListResources`.\n   *\n   * By default, specifying propertyMatch will successfully return 0 or more\n   * results. To throw an error if the number of results is unexpected (and\n   * prevent the query results from being committed to context), specify\n   * `expectedMatchCount`.\n   *\n   * ## Notes on property completeness\n   *\n   * CloudControl API's `ListResources` may return fewer properties than\n   * `GetResource` would, depending on the resource implementation.\n   *\n   * The resources that `propertyMatch` matches against will *only ever* be the\n   * properties returned by the `ListResources` call.\n   *\n   * @default - Either exactIdentifier or propertyMatch should be specified.\n   */\n  readonly propertyMatch?: Record<string, unknown>;\n\n  /**\n   * This is a set of properties returned from CC API that we want to return from ContextQuery.\n   *\n   * If any properties listed here are absent from the target resource, an error will be thrown.\n   *\n   * The returned object will always include the key `Identifier` with the CC-API returned\n   * field `Identifier`.\n   *\n   * ## Notes on property completeness\n   *\n   * CloudControl API's `ListResources` may return fewer properties than\n   * `GetResource` would, depending on the resource implementation.\n   *\n   * The returned properties here are *currently* selected from the response\n   * object that CloudControl API returns to the CDK CLI.\n   *\n   * However, if we find there is need to do so, we may decide to change this\n   * behavior in the future: we might change it to perform an additional\n   * `GetResource` call for resources matched by `propertyMatch`.\n   */\n  readonly propertiesToReturn: string[];\n\n  /**\n   * Expected count of results if `propertyMatch` is specified.\n   *\n   * If the expected result count does not match the actual count,\n   * by default an error is produced and the result is not committed to cached\n   * context, and the user can correct the situation and try again without\n   * having to manually clear out the context key using `cdk context --remove`\n   *\n   * If the value of * `ignoreErrorOnMissingContext` is `true`, the value of\n   * `expectedMatchCount` is `at-least-one | exactly-one` and the number\n   * of found resources is 0, `dummyValue` is returned and committed to context\n   * instead.\n   *\n   * @default 'any'\n   */\n  readonly expectedMatchCount?: 'any' | 'at-least-one' | 'at-most-one' | 'exactly-one';\n\n  /**\n   * The value to return if the resource was not found and `ignoreErrorOnMissingContext` is true.\n   *\n   * If supplied, `dummyValue` should be an array of objects.\n   *\n   * `dummyValue` does not have to have elements, and it may have objects with\n   * different properties than the properties in `propertiesToReturn`, but it\n   * will be easiest for downstream code if the `dummyValue` conforms to\n   * the expected response shape.\n   *\n   * @default - No dummy value available\n   */\n  readonly dummyValue?: any;\n\n  /**\n   * Ignore an error and return the `dummyValue` instead if the resource was not found.\n   *\n   * - In case of an `exactIdentifier` lookup, return the `dummyValue` if the resource with\n   *   that identifier was not found.\n   * - In case of a `propertyMatch` lookup, return the `dummyValue` if `expectedMatchCount`\n   *   is `at-least-one | exactly-one` and the number of resources found was 0.\n   *\n   * if `ignoreErrorOnMissingContext` is set, `dummyValue` should be set and be an array.\n   *\n   * @default false\n   */\n  readonly ignoreErrorOnMissingContext?: boolean;\n}\n\n/**\n * Query input for plugins\n *\n * This alternate branch is necessary because it needs to be able to escape all type checking\n * we do on on the cloud assembly -- we cannot know the properties that will be used a priori.\n */\nexport interface PluginContextQuery {\n  /**\n   * The name of the plugin\n   */\n  readonly pluginName: string;\n\n  /**\n   * Arbitrary other arguments for the plugin.\n   *\n   * This index signature is not usable in non-TypeScript/JavaScript languages.\n   *\n   * @jsii ignore\n   */\n  [key: string]: any;\n}\n\nexport type ContextQueryProperties =\n  | AmiContextQuery\n  | AvailabilityZonesContextQuery\n  | HostedZoneContextQuery\n  | SSMParameterContextQuery\n  | VpcContextQuery\n  | EndpointServiceAvailabilityZonesContextQuery\n  | LoadBalancerContextQuery\n  | LoadBalancerListenerContextQuery\n  | SecurityGroupContextQuery\n  | KeyContextQuery\n  | CcApiContextQuery\n  | PluginContextQuery;\n"]}