@horietakehiro/aws-cdk-utul 0.41.8 → 0.41.10

package/lib/types/cfn-resource-types/aws-elasticloadbalancingv2-listenerrule.d.ts

@@ -15,6 +15,10 @@ export type AuthenticateOidcConfig = ({
      * The token endpoint of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.
      */
     TokenEndpoint: string;
+    /**
+     * Indicates whether to use the existing client secret when modifying a rule. If you are creating a rule, you can omit this parameter or set it to false.
+     */
+    UseExistingClientSecret?: boolean;
     /**
      * The maximum duration of the authentication session, in seconds. The default is 604800 seconds (7 days).
      */
@@ -48,10 +52,6 @@ export type AuthenticateOidcConfig = ({
      * The name of the cookie used to maintain session information. The default is AWSELBAuthSessionCookie.
      */
     SessionCookieName?: string;
-    /**
-     * Indicates whether to use the existing client secret when modifying a rule. If you are creating a rule, you can omit this parameter or set it to false.
-     */
-    UseExistingClientSecret?: boolean;
     /**
      * The query parameters (up to 10) to include in the redirect request to the authorization endpoint.
      */
@@ -63,6 +63,43 @@ export type AuthenticateOidcConfig = ({
         [k: string]: string;
     };
 });
+/**
+ * The strings to compare against the value of the HTTP header. The maximum size of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
+ *  If the same header appears multiple times in the request, we search them in order until a match is found.
+ *  If you specify multiple strings, the condition is satisfied if one of the strings matches the value of the HTTP header. To require that all of the strings are a match, create one condition per string.
+ */
+export type ListOfStrings = string[];
+/**
+ * The condition value. Specify only when ``Field`` is ``host-header`` or ``path-pattern``. Alternatively, to specify multiple host names or multiple path patterns, use ``HostHeaderConfig`` or ``PathPatternConfig``.
+ *  If ``Field`` is ``host-header`` and you're not using ``HostHeaderConfig``, you can specify a single host name (for example, my.example.com). A host name is case insensitive, can be up to 128 characters in length, and can contain any of the following characters.
+ *   +  A-Z, a-z, 0-9
+ *   +  - .
+ *   +  * (matches 0 or more characters)
+ *   +  ? (matches exactly 1 character)
+ *
+ *  If ``Field`` is ``path-pattern`` and you're not using ``PathPatternConfig``, you can specify a single path pattern (for example, /img/*). A path pattern is case-sensitive, can be up to 128 characters in length, and can contain any of the following characters.
+ *   +  A-Z, a-z, 0-9
+ *   +  _ - . $ / ~ " ' @ : +
+ *   +  & (using &)
+ *   +  * (matches 0 or more characters)
+ *   +  ? (matches exactly 1 character)
+ */
+export type ListOfStrings1 = string[];
+/**
+ * The host names. The maximum size of each name is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one "." character. You can include only alphabetical characters after the final "." character.
+ *  If you specify multiple strings, the condition is satisfied if one of the strings matches the host name.
+ */
+export type ListOfStrings2 = string[];
+/**
+ * The name of the request method. The maximum size is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
+ *  If you specify multiple strings, the condition is satisfied if one of the strings matches the HTTP request method. We recommend that you route GET and HEAD requests in the same way, because the response to a HEAD request may be cached.
+ */
+export type ListOfStrings3 = string[];
+/**
+ * The path patterns to compare against the request URL. The maximum size of each string is 128 characters. The comparison is case sensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
+ *  If you specify multiple strings, the condition is satisfied if one of them matches the request URL. The path pattern is compared only to the path of the URL, not to its query string.
+ */
+export type ListOfStrings4 = string[];
 /**
  * Specifies a listener rule. The listener must be associated with an Application Load Balancer. Each rule consists of a priority, one or more actions, and one or more conditions.
  *  For more information, see [Quotas for your Application Load Balancers](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-limits.html) in the *User Guide for Application Load Balancers*.
@@ -72,7 +109,7 @@ export interface _AWS_ELASTICLOADBALANCINGV2_LISTENERRULE {
      * The Amazon Resource Name (ARN) of the listener.
      */
     ListenerArn?: string;
-    RuleArn?: string;
+    IsDefault?: boolean;
     /**
      * The actions.
      *  The rule must include exactly one of the following types of actions: ``forward``, ``fixed-response``, or ``redirect``, and it must be the last action to be performed. If the rule is for an HTTPS listener, it can also optionally include an authentication action.
@@ -83,12 +120,12 @@ export interface _AWS_ELASTICLOADBALANCINGV2_LISTENERRULE {
      *  If you try to reorder rules by updating their priorities, do not specify a new priority if an existing rule already uses this priority, as this can cause an error. If you need to reuse a priority with a different rule, you must remove it as a priority first, and then specify it in a subsequent update.
      */
     Priority: number;
+    RuleArn?: string;
     /**
      * The conditions.
      *  The rule can optionally include up to one of each of the following conditions: ``http-request-method``, ``host-header``, ``path-pattern``, and ``source-ip``. A rule can also optionally include one or more of each of the following conditions: ``http-header`` and ``query-string``.
      */
     Conditions: RuleCondition[];
-    IsDefault?: boolean;
 }
 /**
  * Specifies an action for a listener rule.
@@ -225,7 +262,7 @@ export interface TargetGroupStickinessConfig {
      */
     Enabled?: boolean;
     /**
-     * The time period, in seconds, during which requests from a client should be routed to the same target group. The range is 1-604800 seconds (7 days).
+     * The time period, in seconds, during which requests from a client should be routed to the same target group. The range is 1-604800 seconds (7 days). You must specify this value when enabling target group stickiness.
      */
     DurationSeconds?: number;
 }
@@ -256,84 +293,24 @@ export interface RuleCondition {
      *   +   ``source-ip``
      */
     Field?: string;
-    /**
-     * The condition value. Specify only when ``Field`` is ``host-header`` or ``path-pattern``. Alternatively, to specify multiple host names or multiple path patterns, use ``HostHeaderConfig`` or ``PathPatternConfig``.
-     *  If ``Field`` is ``host-header`` and you're not using ``HostHeaderConfig``, you can specify a single host name (for example, my.example.com). A host name is case insensitive, can be up to 128 characters in length, and can contain any of the following characters.
-     *   +  A-Z, a-z, 0-9
-     *   +  - .
-     *   +  * (matches 0 or more characters)
-     *   +  ? (matches exactly 1 character)
-     *
-     *  If ``Field`` is ``path-pattern`` and you're not using ``PathPatternConfig``, you can specify a single path pattern (for example, /img/*). A path pattern is case-sensitive, can be up to 128 characters in length, and can contain any of the following characters.
-     *   +  A-Z, a-z, 0-9
-     *   +  _ - . $ / ~ " ' @ : +
-     *   +  & (using &)
-     *   +  * (matches 0 or more characters)
-     *   +  ? (matches exactly 1 character)
-     */
-    Values?: string[];
+    HttpHeaderConfig?: HttpHeaderConfig;
+    Values?: ListOfStrings1;
+    QueryStringConfig?: QueryStringConfig;
+    HostHeaderConfig?: HostHeaderConfig;
     HttpRequestMethodConfig?: HttpRequestMethodConfig;
     PathPatternConfig?: PathPatternConfig;
-    HttpHeaderConfig?: HttpHeaderConfig;
     SourceIpConfig?: SourceIpConfig;
-    HostHeaderConfig?: HostHeaderConfig;
-    QueryStringConfig?: QueryStringConfig;
-}
-/**
- * Information for an HTTP method condition. Specify only when ``Field`` is ``http-request-method``.
- */
-export interface HttpRequestMethodConfig {
-    /**
-     * The name of the request method. The maximum size is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
-     *  If you specify multiple strings, the condition is satisfied if one of the strings matches the HTTP request method. We recommend that you route GET and HEAD requests in the same way, because the response to a HEAD request may be cached.
-     */
-    Values?: string[];
-}
-/**
- * Information for a path pattern condition. Specify only when ``Field`` is ``path-pattern``.
- */
-export interface PathPatternConfig {
-    /**
-     * The path patterns to compare against the request URL. The maximum size of each string is 128 characters. The comparison is case sensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
-     *  If you specify multiple strings, the condition is satisfied if one of them matches the request URL. The path pattern is compared only to the path of the URL, not to its query string.
-     */
-    Values?: string[];
 }
 /**
  * Information for an HTTP header condition. Specify only when ``Field`` is ``http-header``.
  */
 export interface HttpHeaderConfig {
-    /**
-     * The strings to compare against the value of the HTTP header. The maximum size of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
-     *  If the same header appears multiple times in the request, we search them in order until a match is found.
-     *  If you specify multiple strings, the condition is satisfied if one of the strings matches the value of the HTTP header. To require that all of the strings are a match, create one condition per string.
-     */
-    Values?: string[];
+    Values?: ListOfStrings;
     /**
      * The name of the HTTP header field. The maximum size is 40 characters. The header name is case insensitive. The allowed characters are specified by RFC 7230. Wildcards are not supported.
      */
     HttpHeaderName?: string;
 }
-/**
- * Information for a source IP condition. Specify only when ``Field`` is ``source-ip``.
- */
-export interface SourceIpConfig {
-    /**
-     * The source IP addresses, in CIDR format. You can use both IPv4 and IPv6 addresses. Wildcards are not supported.
-     *  If you specify multiple addresses, the condition is satisfied if the source IP address of the request matches one of the CIDR blocks. This condition is not satisfied by the addresses in the X-Forwarded-For header.
-     */
-    Values?: string[];
-}
-/**
- * Information for a host header condition. Specify only when ``Field`` is ``host-header``.
- */
-export interface HostHeaderConfig {
-    /**
-     * The host names. The maximum size of each name is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
-     *  If you specify multiple strings, the condition is satisfied if one of the strings matches the host name.
-     */
-    Values?: string[];
-}
 /**
  * Information for a query string condition. Specify only when ``Field`` is ``query-string``.
  */
@@ -357,3 +334,31 @@ export interface QueryStringKeyValue {
      */
     Key?: string;
 }
+/**
+ * Information for a host header condition. Specify only when ``Field`` is ``host-header``.
+ */
+export interface HostHeaderConfig {
+    Values?: ListOfStrings2;
+}
+/**
+ * Information for an HTTP method condition. Specify only when ``Field`` is ``http-request-method``.
+ */
+export interface HttpRequestMethodConfig {
+    Values?: ListOfStrings3;
+}
+/**
+ * Information for a path pattern condition. Specify only when ``Field`` is ``path-pattern``.
+ */
+export interface PathPatternConfig {
+    Values?: ListOfStrings4;
+}
+/**
+ * Information for a source IP condition. Specify only when ``Field`` is ``source-ip``.
+ */
+export interface SourceIpConfig {
+    /**
+     * The source IP addresses, in CIDR format. You can use both IPv4 and IPv6 addresses. Wildcards are not supported.
+     *  If you specify multiple addresses, the condition is satisfied if the source IP address of the request matches one of the CIDR blocks. This condition is not satisfied by the addresses in the X-Forwarded-For header.
+     */
+    Values?: string[];
+}

package/lib/types/cfn-resource-types/aws-elasticloadbalancingv2-listenerrule.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-elasticloadbalancingv2-listenerrule.js","sourceRoot":"","sources":["aws-elasticloadbalancingv2-listenerrule.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * [HTTPS listeners] Information about an identity provider that is compliant with OpenID Connect (OIDC). Specify only when ``Type`` is ``authenticate-oidc``.\n */\nexport type AuthenticateOidcConfig = ({\n[k: string]: unknown\n} & {\n/**\n * The behavior if the user is not authenticated. The following are possible values:\n *   +  deny```` - Return an HTTP 401 Unauthorized error.\n *   +  allow```` - Allow the request to be forwarded to the target.\n *   +  authenticate```` - Redirect the request to the IdP authorization endpoint. This is the default value.\n */\nOnUnauthenticatedRequest?: string\n/**\n * The token endpoint of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.\n */\nTokenEndpoint: string\n/**\n * The maximum duration of the authentication session, in seconds. The default is 604800 seconds (7 days).\n */\nSessionTimeout?: number\n/**\n * The set of user claims to be requested from the IdP. The default is ``openid``.\n *  To verify which scope values your IdP supports and how to separate multiple values, see the documentation for your IdP.\n */\nScope?: string\n/**\n * The OIDC issuer identifier of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.\n */\nIssuer: string\n/**\n * The OAuth 2.0 client secret. This parameter is required if you are creating a rule. If you are modifying a rule, you can omit this parameter if you set ``UseExistingClientSecret`` to true.\n */\nClientSecret?: string\n/**\n * The user info endpoint of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.\n */\nUserInfoEndpoint: string\n/**\n * The OAuth 2.0 client identifier.\n */\nClientId: string\n/**\n * The authorization endpoint of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.\n */\nAuthorizationEndpoint: string\n/**\n * The name of the cookie used to maintain session information. The default is AWSELBAuthSessionCookie.\n */\nSessionCookieName?: string\n/**\n * Indicates whether to use the existing client secret when modifying a rule. If you are creating a rule, you can omit this parameter or set it to false.\n */\nUseExistingClientSecret?: boolean\n/**\n * The query parameters (up to 10) to include in the redirect request to the authorization endpoint.\n */\nAuthenticationRequestExtraParams?: {\n/**\n * This interface was referenced by `undefined`'s JSON-Schema definition\n * via the `patternProperty` \"[a-zA-Z0-9]+\".\n */\n[k: string]: string\n}\n})\n\n/**\n * Specifies a listener rule. The listener must be associated with an Application Load Balancer. Each rule consists of a priority, one or more actions, and one or more conditions.\n *  For more information, see [Quotas for your Application Load Balancers](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-limits.html) in the *User Guide for Application Load Balancers*.\n */\nexport interface _AWS_ELASTICLOADBALANCINGV2_LISTENERRULE {\n/**\n * The Amazon Resource Name (ARN) of the listener.\n */\nListenerArn?: string\nRuleArn?: string\n/**\n * The actions.\n *  The rule must include exactly one of the following types of actions: ``forward``, ``fixed-response``, or ``redirect``, and it must be the last action to be performed. If the rule is for an HTTPS listener, it can also optionally include an authentication action.\n */\nActions: Action[]\n/**\n * The rule priority. A listener can't have multiple rules with the same priority.\n *  If you try to reorder rules by updating their priorities, do not specify a new priority if an existing rule already uses this priority, as this can cause an error. If you need to reuse a priority with a different rule, you must remove it as a priority first, and then specify it in a subsequent update.\n */\nPriority: number\n/**\n * The conditions.\n *  The rule can optionally include up to one of each of the following conditions: ``http-request-method``, ``host-header``, ``path-pattern``, and ``source-ip``. A rule can also optionally include one or more of each of the following conditions: ``http-header`` and ``query-string``.\n */\nConditions: RuleCondition[]\nIsDefault?: boolean\n}\n/**\n * Specifies an action for a listener rule.\n */\nexport interface Action {\n/**\n * The order for the action. This value is required for rules with multiple actions. The action with the lowest value for order is performed first.\n */\nOrder?: number\n/**\n * The Amazon Resource Name (ARN) of the target group. Specify only when ``Type`` is ``forward`` and you want to route to a single target group. To route to one or more target groups, use ``ForwardConfig`` instead.\n */\nTargetGroupArn?: string\nFixedResponseConfig?: FixedResponseConfig\nAuthenticateCognitoConfig?: AuthenticateCognitoConfig\n/**\n * The type of action.\n */\nType: string\nRedirectConfig?: RedirectConfig\nForwardConfig?: ForwardConfig\nAuthenticateOidcConfig?: AuthenticateOidcConfig\n}\n/**\n * [Application Load Balancer] Information for creating an action that returns a custom HTTP response. Specify only when ``Type`` is ``fixed-response``.\n */\nexport interface FixedResponseConfig {\n/**\n * The content type.\n *  Valid Values: text/plain | text/css | text/html | application/javascript | application/json\n */\nContentType?: string\n/**\n * The HTTP response code (2XX, 4XX, or 5XX).\n */\nStatusCode: string\n/**\n * The message.\n */\nMessageBody?: string\n}\n/**\n * [HTTPS listeners] Information for using Amazon Cognito to authenticate users. Specify only when ``Type`` is ``authenticate-cognito``.\n */\nexport interface AuthenticateCognitoConfig {\n/**\n * The behavior if the user is not authenticated. The following are possible values:\n *   +  deny```` - Return an HTTP 401 Unauthorized error.\n *   +  allow```` - Allow the request to be forwarded to the target.\n *   +  authenticate```` - Redirect the request to the IdP authorization endpoint. This is the default value.\n */\nOnUnauthenticatedRequest?: string\n/**\n * The ID of the Amazon Cognito user pool client.\n */\nUserPoolClientId: string\n/**\n * The domain prefix or fully-qualified domain name of the Amazon Cognito user pool.\n */\nUserPoolDomain: string\n/**\n * The maximum duration of the authentication session, in seconds. The default is 604800 seconds (7 days).\n */\nSessionTimeout?: number\n/**\n * The set of user claims to be requested from the IdP. The default is ``openid``.\n *  To verify which scope values your IdP supports and how to separate multiple values, see the documentation for your IdP.\n */\nScope?: string\n/**\n * The name of the cookie used to maintain session information. The default is AWSELBAuthSessionCookie.\n */\nSessionCookieName?: string\n/**\n * The Amazon Resource Name (ARN) of the Amazon Cognito user pool.\n */\nUserPoolArn: string\n/**\n * The query parameters (up to 10) to include in the redirect request to the authorization endpoint.\n */\nAuthenticationRequestExtraParams?: {\n/**\n * This interface was referenced by `undefined`'s JSON-Schema definition\n * via the `patternProperty` \"[a-zA-Z0-9]+\".\n */\n[k: string]: string\n}\n}\n/**\n * [Application Load Balancer] Information for creating a redirect action. Specify only when ``Type`` is ``redirect``.\n */\nexport interface RedirectConfig {\n/**\n * The absolute path, starting with the leading \"/\". This component is not percent-encoded. The path can contain #{host}, #{path}, and #{port}.\n */\nPath?: string\n/**\n * The query parameters, URL-encoded when necessary, but not percent-encoded. Do not include the leading \"?\", as it is automatically added. You can specify any of the reserved keywords.\n */\nQuery?: string\n/**\n * The port. You can specify a value from 1 to 65535 or #{port}.\n */\nPort?: string\n/**\n * The hostname. This component is not percent-encoded. The hostname can contain #{host}.\n */\nHost?: string\n/**\n * The protocol. You can specify HTTP, HTTPS, or #{protocol}. You can redirect HTTP to HTTP, HTTP to HTTPS, and HTTPS to HTTPS. You can't redirect HTTPS to HTTP.\n */\nProtocol?: string\n/**\n * The HTTP redirect code. The redirect is either permanent (HTTP 301) or temporary (HTTP 302).\n */\nStatusCode: string\n}\n/**\n * Information for creating an action that distributes requests among one or more target groups. For Network Load Balancers, you can specify a single target group. Specify only when ``Type`` is ``forward``. If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.\n */\nexport interface ForwardConfig {\nTargetGroupStickinessConfig?: TargetGroupStickinessConfig\n/**\n * Information about how traffic will be distributed between multiple target groups in a forward rule.\n */\nTargetGroups?: TargetGroupTuple[]\n}\n/**\n * Information about the target group stickiness for a rule.\n */\nexport interface TargetGroupStickinessConfig {\n/**\n * Indicates whether target group stickiness is enabled.\n */\nEnabled?: boolean\n/**\n * The time period, in seconds, during which requests from a client should be routed to the same target group. The range is 1-604800 seconds (7 days).\n */\nDurationSeconds?: number\n}\n/**\n * Information about how traffic will be distributed between multiple target groups in a forward rule.\n */\nexport interface TargetGroupTuple {\n/**\n * The Amazon Resource Name (ARN) of the target group.\n */\nTargetGroupArn?: string\n/**\n * The weight. The range is 0 to 999.\n */\nWeight?: number\n}\n/**\n * Specifies a condition for a listener rule.\n */\nexport interface RuleCondition {\n/**\n * The field in the HTTP request. The following are the possible values:\n *   +   ``http-header`` \n *   +   ``http-request-method`` \n *   +   ``host-header`` \n *   +   ``path-pattern`` \n *   +   ``query-string`` \n *   +   ``source-ip``\n */\nField?: string\n/**\n * The condition value. Specify only when ``Field`` is ``host-header`` or ``path-pattern``. Alternatively, to specify multiple host names or multiple path patterns, use ``HostHeaderConfig`` or ``PathPatternConfig``.\n *  If ``Field`` is ``host-header`` and you're not using ``HostHeaderConfig``, you can specify a single host name (for example, my.example.com). A host name is case insensitive, can be up to 128 characters in length, and can contain any of the following characters.\n *   +  A-Z, a-z, 0-9\n *   +  - .\n *   +  * (matches 0 or more characters)\n *   +  ? (matches exactly 1 character)\n *   \n *  If ``Field`` is ``path-pattern`` and you're not using ``PathPatternConfig``, you can specify a single path pattern (for example, /img/*). A path pattern is case-sensitive, can be up to 128 characters in length, and can contain any of the following characters.\n *   +  A-Z, a-z, 0-9\n *   +  _ - . $ / ~ \" ' @ : +\n *   +  & (using &amp;)\n *   +  * (matches 0 or more characters)\n *   +  ? (matches exactly 1 character)\n */\nValues?: string[]\nHttpRequestMethodConfig?: HttpRequestMethodConfig\nPathPatternConfig?: PathPatternConfig\nHttpHeaderConfig?: HttpHeaderConfig\nSourceIpConfig?: SourceIpConfig\nHostHeaderConfig?: HostHeaderConfig\nQueryStringConfig?: QueryStringConfig\n}\n/**\n * Information for an HTTP method condition. Specify only when ``Field`` is ``http-request-method``.\n */\nexport interface HttpRequestMethodConfig {\n/**\n * The name of the request method. The maximum size is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.\n *  If you specify multiple strings, the condition is satisfied if one of the strings matches the HTTP request method. We recommend that you route GET and HEAD requests in the same way, because the response to a HEAD request may be cached.\n */\nValues?: string[]\n}\n/**\n * Information for a path pattern condition. Specify only when ``Field`` is ``path-pattern``.\n */\nexport interface PathPatternConfig {\n/**\n * The path patterns to compare against the request URL. The maximum size of each string is 128 characters. The comparison is case sensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).\n *  If you specify multiple strings, the condition is satisfied if one of them matches the request URL. The path pattern is compared only to the path of the URL, not to its query string.\n */\nValues?: string[]\n}\n/**\n * Information for an HTTP header condition. Specify only when ``Field`` is ``http-header``.\n */\nexport interface HttpHeaderConfig {\n/**\n * The strings to compare against the value of the HTTP header. The maximum size of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).\n *  If the same header appears multiple times in the request, we search them in order until a match is found.\n *  If you specify multiple strings, the condition is satisfied if one of the strings matches the value of the HTTP header. To require that all of the strings are a match, create one condition per string.\n */\nValues?: string[]\n/**\n * The name of the HTTP header field. The maximum size is 40 characters. The header name is case insensitive. The allowed characters are specified by RFC 7230. Wildcards are not supported.\n */\nHttpHeaderName?: string\n}\n/**\n * Information for a source IP condition. Specify only when ``Field`` is ``source-ip``.\n */\nexport interface SourceIpConfig {\n/**\n * The source IP addresses, in CIDR format. You can use both IPv4 and IPv6 addresses. Wildcards are not supported.\n *  If you specify multiple addresses, the condition is satisfied if the source IP address of the request matches one of the CIDR blocks. This condition is not satisfied by the addresses in the X-Forwarded-For header.\n */\nValues?: string[]\n}\n/**\n * Information for a host header condition. Specify only when ``Field`` is ``host-header``.\n */\nexport interface HostHeaderConfig {\n/**\n * The host names. The maximum size of each name is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).\n *  If you specify multiple strings, the condition is satisfied if one of the strings matches the host name.\n */\nValues?: string[]\n}\n/**\n * Information for a query string condition. Specify only when ``Field`` is ``query-string``.\n */\nexport interface QueryStringConfig {\n/**\n * The key/value pairs or values to find in the query string. The maximum size of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.\n *  If you specify multiple key/value pairs or values, the condition is satisfied if one of them is found in the query string.\n */\nValues?: QueryStringKeyValue[]\n}\n/**\n * Information about a key/value pair.\n */\nexport interface QueryStringKeyValue {\n/**\n * The value.\n */\nValue?: string\n/**\n * The key. You can omit the key.\n */\nKey?: string\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-elasticloadbalancingv2-listenerrule.js","sourceRoot":"","sources":["aws-elasticloadbalancingv2-listenerrule.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * [HTTPS listeners] Information about an identity provider that is compliant with OpenID Connect (OIDC). Specify only when ``Type`` is ``authenticate-oidc``.\n */\nexport type AuthenticateOidcConfig = ({\n[k: string]: unknown\n} & {\n/**\n * The behavior if the user is not authenticated. The following are possible values:\n *   +  deny```` - Return an HTTP 401 Unauthorized error.\n *   +  allow```` - Allow the request to be forwarded to the target.\n *   +  authenticate```` - Redirect the request to the IdP authorization endpoint. This is the default value.\n */\nOnUnauthenticatedRequest?: string\n/**\n * The token endpoint of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.\n */\nTokenEndpoint: string\n/**\n * Indicates whether to use the existing client secret when modifying a rule. If you are creating a rule, you can omit this parameter or set it to false.\n */\nUseExistingClientSecret?: boolean\n/**\n * The maximum duration of the authentication session, in seconds. The default is 604800 seconds (7 days).\n */\nSessionTimeout?: number\n/**\n * The set of user claims to be requested from the IdP. The default is ``openid``.\n *  To verify which scope values your IdP supports and how to separate multiple values, see the documentation for your IdP.\n */\nScope?: string\n/**\n * The OIDC issuer identifier of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.\n */\nIssuer: string\n/**\n * The OAuth 2.0 client secret. This parameter is required if you are creating a rule. If you are modifying a rule, you can omit this parameter if you set ``UseExistingClientSecret`` to true.\n */\nClientSecret?: string\n/**\n * The user info endpoint of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.\n */\nUserInfoEndpoint: string\n/**\n * The OAuth 2.0 client identifier.\n */\nClientId: string\n/**\n * The authorization endpoint of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.\n */\nAuthorizationEndpoint: string\n/**\n * The name of the cookie used to maintain session information. The default is AWSELBAuthSessionCookie.\n */\nSessionCookieName?: string\n/**\n * The query parameters (up to 10) to include in the redirect request to the authorization endpoint.\n */\nAuthenticationRequestExtraParams?: {\n/**\n * This interface was referenced by `undefined`'s JSON-Schema definition\n * via the `patternProperty` \"[a-zA-Z0-9]+\".\n */\n[k: string]: string\n}\n})\n/**\n * The strings to compare against the value of the HTTP header. The maximum size of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).\n *  If the same header appears multiple times in the request, we search them in order until a match is found.\n *  If you specify multiple strings, the condition is satisfied if one of the strings matches the value of the HTTP header. To require that all of the strings are a match, create one condition per string.\n */\nexport type ListOfStrings = string[]\n/**\n * The condition value. Specify only when ``Field`` is ``host-header`` or ``path-pattern``. Alternatively, to specify multiple host names or multiple path patterns, use ``HostHeaderConfig`` or ``PathPatternConfig``.\n *  If ``Field`` is ``host-header`` and you're not using ``HostHeaderConfig``, you can specify a single host name (for example, my.example.com). A host name is case insensitive, can be up to 128 characters in length, and can contain any of the following characters.\n *   +  A-Z, a-z, 0-9\n *   +  - .\n *   +  * (matches 0 or more characters)\n *   +  ? (matches exactly 1 character)\n *   \n *  If ``Field`` is ``path-pattern`` and you're not using ``PathPatternConfig``, you can specify a single path pattern (for example, /img/*). A path pattern is case-sensitive, can be up to 128 characters in length, and can contain any of the following characters.\n *   +  A-Z, a-z, 0-9\n *   +  _ - . $ / ~ \" ' @ : +\n *   +  & (using &amp;)\n *   +  * (matches 0 or more characters)\n *   +  ? (matches exactly 1 character)\n */\nexport type ListOfStrings1 = string[]\n/**\n * The host names. The maximum size of each name is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one \".\" character. You can include only alphabetical characters after the final \".\" character.\n *  If you specify multiple strings, the condition is satisfied if one of the strings matches the host name.\n */\nexport type ListOfStrings2 = string[]\n/**\n * The name of the request method. The maximum size is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.\n *  If you specify multiple strings, the condition is satisfied if one of the strings matches the HTTP request method. We recommend that you route GET and HEAD requests in the same way, because the response to a HEAD request may be cached.\n */\nexport type ListOfStrings3 = string[]\n/**\n * The path patterns to compare against the request URL. The maximum size of each string is 128 characters. The comparison is case sensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).\n *  If you specify multiple strings, the condition is satisfied if one of them matches the request URL. The path pattern is compared only to the path of the URL, not to its query string.\n */\nexport type ListOfStrings4 = string[]\n\n/**\n * Specifies a listener rule. The listener must be associated with an Application Load Balancer. Each rule consists of a priority, one or more actions, and one or more conditions.\n *  For more information, see [Quotas for your Application Load Balancers](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-limits.html) in the *User Guide for Application Load Balancers*.\n */\nexport interface _AWS_ELASTICLOADBALANCINGV2_LISTENERRULE {\n/**\n * The Amazon Resource Name (ARN) of the listener.\n */\nListenerArn?: string\nIsDefault?: boolean\n/**\n * The actions.\n *  The rule must include exactly one of the following types of actions: ``forward``, ``fixed-response``, or ``redirect``, and it must be the last action to be performed. If the rule is for an HTTPS listener, it can also optionally include an authentication action.\n */\nActions: Action[]\n/**\n * The rule priority. A listener can't have multiple rules with the same priority.\n *  If you try to reorder rules by updating their priorities, do not specify a new priority if an existing rule already uses this priority, as this can cause an error. If you need to reuse a priority with a different rule, you must remove it as a priority first, and then specify it in a subsequent update.\n */\nPriority: number\nRuleArn?: string\n/**\n * The conditions.\n *  The rule can optionally include up to one of each of the following conditions: ``http-request-method``, ``host-header``, ``path-pattern``, and ``source-ip``. A rule can also optionally include one or more of each of the following conditions: ``http-header`` and ``query-string``.\n */\nConditions: RuleCondition[]\n}\n/**\n * Specifies an action for a listener rule.\n */\nexport interface Action {\n/**\n * The order for the action. This value is required for rules with multiple actions. The action with the lowest value for order is performed first.\n */\nOrder?: number\n/**\n * The Amazon Resource Name (ARN) of the target group. Specify only when ``Type`` is ``forward`` and you want to route to a single target group. To route to one or more target groups, use ``ForwardConfig`` instead.\n */\nTargetGroupArn?: string\nFixedResponseConfig?: FixedResponseConfig\nAuthenticateCognitoConfig?: AuthenticateCognitoConfig\n/**\n * The type of action.\n */\nType: string\nRedirectConfig?: RedirectConfig\nForwardConfig?: ForwardConfig\nAuthenticateOidcConfig?: AuthenticateOidcConfig\n}\n/**\n * [Application Load Balancer] Information for creating an action that returns a custom HTTP response. Specify only when ``Type`` is ``fixed-response``.\n */\nexport interface FixedResponseConfig {\n/**\n * The content type.\n *  Valid Values: text/plain | text/css | text/html | application/javascript | application/json\n */\nContentType?: string\n/**\n * The HTTP response code (2XX, 4XX, or 5XX).\n */\nStatusCode: string\n/**\n * The message.\n */\nMessageBody?: string\n}\n/**\n * [HTTPS listeners] Information for using Amazon Cognito to authenticate users. Specify only when ``Type`` is ``authenticate-cognito``.\n */\nexport interface AuthenticateCognitoConfig {\n/**\n * The behavior if the user is not authenticated. The following are possible values:\n *   +  deny```` - Return an HTTP 401 Unauthorized error.\n *   +  allow```` - Allow the request to be forwarded to the target.\n *   +  authenticate```` - Redirect the request to the IdP authorization endpoint. This is the default value.\n */\nOnUnauthenticatedRequest?: string\n/**\n * The ID of the Amazon Cognito user pool client.\n */\nUserPoolClientId: string\n/**\n * The domain prefix or fully-qualified domain name of the Amazon Cognito user pool.\n */\nUserPoolDomain: string\n/**\n * The maximum duration of the authentication session, in seconds. The default is 604800 seconds (7 days).\n */\nSessionTimeout?: number\n/**\n * The set of user claims to be requested from the IdP. The default is ``openid``.\n *  To verify which scope values your IdP supports and how to separate multiple values, see the documentation for your IdP.\n */\nScope?: string\n/**\n * The name of the cookie used to maintain session information. The default is AWSELBAuthSessionCookie.\n */\nSessionCookieName?: string\n/**\n * The Amazon Resource Name (ARN) of the Amazon Cognito user pool.\n */\nUserPoolArn: string\n/**\n * The query parameters (up to 10) to include in the redirect request to the authorization endpoint.\n */\nAuthenticationRequestExtraParams?: {\n/**\n * This interface was referenced by `undefined`'s JSON-Schema definition\n * via the `patternProperty` \"[a-zA-Z0-9]+\".\n */\n[k: string]: string\n}\n}\n/**\n * [Application Load Balancer] Information for creating a redirect action. Specify only when ``Type`` is ``redirect``.\n */\nexport interface RedirectConfig {\n/**\n * The absolute path, starting with the leading \"/\". This component is not percent-encoded. The path can contain #{host}, #{path}, and #{port}.\n */\nPath?: string\n/**\n * The query parameters, URL-encoded when necessary, but not percent-encoded. Do not include the leading \"?\", as it is automatically added. You can specify any of the reserved keywords.\n */\nQuery?: string\n/**\n * The port. You can specify a value from 1 to 65535 or #{port}.\n */\nPort?: string\n/**\n * The hostname. This component is not percent-encoded. The hostname can contain #{host}.\n */\nHost?: string\n/**\n * The protocol. You can specify HTTP, HTTPS, or #{protocol}. You can redirect HTTP to HTTP, HTTP to HTTPS, and HTTPS to HTTPS. You can't redirect HTTPS to HTTP.\n */\nProtocol?: string\n/**\n * The HTTP redirect code. The redirect is either permanent (HTTP 301) or temporary (HTTP 302).\n */\nStatusCode: string\n}\n/**\n * Information for creating an action that distributes requests among one or more target groups. For Network Load Balancers, you can specify a single target group. Specify only when ``Type`` is ``forward``. If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.\n */\nexport interface ForwardConfig {\nTargetGroupStickinessConfig?: TargetGroupStickinessConfig\n/**\n * Information about how traffic will be distributed between multiple target groups in a forward rule.\n */\nTargetGroups?: TargetGroupTuple[]\n}\n/**\n * Information about the target group stickiness for a rule.\n */\nexport interface TargetGroupStickinessConfig {\n/**\n * Indicates whether target group stickiness is enabled.\n */\nEnabled?: boolean\n/**\n * The time period, in seconds, during which requests from a client should be routed to the same target group. The range is 1-604800 seconds (7 days). You must specify this value when enabling target group stickiness.\n */\nDurationSeconds?: number\n}\n/**\n * Information about how traffic will be distributed between multiple target groups in a forward rule.\n */\nexport interface TargetGroupTuple {\n/**\n * The Amazon Resource Name (ARN) of the target group.\n */\nTargetGroupArn?: string\n/**\n * The weight. The range is 0 to 999.\n */\nWeight?: number\n}\n/**\n * Specifies a condition for a listener rule.\n */\nexport interface RuleCondition {\n/**\n * The field in the HTTP request. The following are the possible values:\n *   +   ``http-header`` \n *   +   ``http-request-method`` \n *   +   ``host-header`` \n *   +   ``path-pattern`` \n *   +   ``query-string`` \n *   +   ``source-ip``\n */\nField?: string\nHttpHeaderConfig?: HttpHeaderConfig\nValues?: ListOfStrings1\nQueryStringConfig?: QueryStringConfig\nHostHeaderConfig?: HostHeaderConfig\nHttpRequestMethodConfig?: HttpRequestMethodConfig\nPathPatternConfig?: PathPatternConfig\nSourceIpConfig?: SourceIpConfig\n}\n/**\n * Information for an HTTP header condition. Specify only when ``Field`` is ``http-header``.\n */\nexport interface HttpHeaderConfig {\nValues?: ListOfStrings\n/**\n * The name of the HTTP header field. The maximum size is 40 characters. The header name is case insensitive. The allowed characters are specified by RFC 7230. Wildcards are not supported.\n */\nHttpHeaderName?: string\n}\n/**\n * Information for a query string condition. Specify only when ``Field`` is ``query-string``.\n */\nexport interface QueryStringConfig {\n/**\n * The key/value pairs or values to find in the query string. The maximum size of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.\n *  If you specify multiple key/value pairs or values, the condition is satisfied if one of them is found in the query string.\n */\nValues?: QueryStringKeyValue[]\n}\n/**\n * Information about a key/value pair.\n */\nexport interface QueryStringKeyValue {\n/**\n * The value.\n */\nValue?: string\n/**\n * The key. You can omit the key.\n */\nKey?: string\n}\n/**\n * Information for a host header condition. Specify only when ``Field`` is ``host-header``.\n */\nexport interface HostHeaderConfig {\nValues?: ListOfStrings2\n}\n/**\n * Information for an HTTP method condition. Specify only when ``Field`` is ``http-request-method``.\n */\nexport interface HttpRequestMethodConfig {\nValues?: ListOfStrings3\n}\n/**\n * Information for a path pattern condition. Specify only when ``Field`` is ``path-pattern``.\n */\nexport interface PathPatternConfig {\nValues?: ListOfStrings4\n}\n/**\n * Information for a source IP condition. Specify only when ``Field`` is ``source-ip``.\n */\nexport interface SourceIpConfig {\n/**\n * The source IP addresses, in CIDR format. You can use both IPv4 and IPv6 addresses. Wildcards are not supported.\n *  If you specify multiple addresses, the condition is satisfied if the source IP address of the request matches one of the CIDR blocks. This condition is not satisfied by the addresses in the X-Forwarded-For header.\n */\nValues?: string[]\n}\n"]}

package/lib/types/cfn-resource-types/aws-elasticloadbalancingv2-loadbalancer.d.ts

@@ -18,7 +18,7 @@ export interface _AWS_ELASTICLOADBALANCINGV2_LOADBALANCER {
      */
     SecurityGroups?: string[];
     /**
-     * The load balancer attributes.
+     * The load balancer attributes. Attributes that you do not modify retain their current values.
      */
     LoadBalancerAttributes?: LoadBalancerAttribute[];
     MinimumLoadBalancerCapacity?: MinimumLoadBalancerCapacity;

package/lib/types/cfn-resource-types/aws-elasticloadbalancingv2-loadbalancer.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-elasticloadbalancingv2-loadbalancer.js","sourceRoot":"","sources":["aws-elasticloadbalancingv2-loadbalancer.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Specifies an Application Load Balancer, a Network Load Balancer, or a Gateway Load Balancer.\n */\nexport interface _AWS_ELASTICLOADBALANCINGV2_LOADBALANCER {\n/**\n * The IP address type. Internal load balancers must use ``ipv4``.\n *  [Application Load Balancers] The possible values are ``ipv4`` (IPv4 addresses), ``dualstack`` (IPv4 and IPv6 addresses), and ``dualstack-without-public-ipv4`` (public IPv6 addresses and private IPv4 and IPv6 addresses).\n *  Application Load Balancer authentication supports IPv4 addresses only when connecting to an Identity Provider (IdP) or Amazon Cognito endpoint. Without a public IPv4 address the load balancer can't complete the authentication process, resulting in HTTP 500 errors.\n *  [Network Load Balancers and Gateway Load Balancers] The possible values are ``ipv4`` (IPv4 addresses) and ``dualstack`` (IPv4 and IPv6 addresses).\n */\nIpAddressType?: string\n/**\n * [Network Load Balancers with UDP listeners] Indicates whether to use an IPv6 prefix from each subnet for source NAT. The IP address type must be ``dualstack``. The default value is ``off``.\n */\nEnablePrefixForIpv6SourceNat?: string\n/**\n * [Application Load Balancers and Network Load Balancers] The IDs of the security groups for the load balancer.\n */\nSecurityGroups?: string[]\n/**\n * The load balancer attributes.\n */\nLoadBalancerAttributes?: LoadBalancerAttribute[]\nMinimumLoadBalancerCapacity?: MinimumLoadBalancerCapacity\n/**\n * The nodes of an Internet-facing load balancer have public IP addresses. The DNS name of an Internet-facing load balancer is publicly resolvable to the public IP addresses of the nodes. Therefore, Internet-facing load balancers can route requests from clients over the internet.\n *  The nodes of an internal load balancer have only private IP addresses. The DNS name of an internal load balancer is publicly resolvable to the private IP addresses of the nodes. Therefore, internal load balancers can route requests only from clients with access to the VPC for the load balancer.\n *  The default is an Internet-facing load balancer.\n *  You can't specify a scheme for a Gateway Load Balancer.\n */\nScheme?: string\nDNSName?: string\n/**\n * The name of the load balancer. This name must be unique per region per account, can have a maximum of 32 characters, must contain only alphanumeric characters or hyphens, must not begin or end with a hyphen, and must not begin with \"internal-\".\n *  If you don't specify a name, AWS CloudFormation generates a unique physical ID for the load balancer. If you specify a name, you cannot perform updates that require replacement of this resource, but you can perform other updates. To replace the resource, specify a new name.\n */\nName?: string\nLoadBalancerName?: string\nLoadBalancerFullName?: string\n/**\n * The IDs of the subnets. You can specify only one subnet per Availability Zone. You must specify either subnets or subnet mappings, but not both. To specify an Elastic IP address, specify subnet mappings instead of subnets.\n *  [Application Load Balancers] You must specify subnets from at least two Availability Zones.\n *  [Application Load Balancers on Outposts] You must specify one Outpost subnet.\n *  [Application Load Balancers on Local Zones] You can specify subnets from one or more Local Zones.\n *  [Network Load Balancers and Gateway Load Balancers] You can specify subnets from one or more Availability Zones.\n */\nSubnets?: string[]\n/**\n * The type of load balancer. The default is ``application``.\n */\nType?: string\nCanonicalHostedZoneID?: string\n/**\n * The tags to assign to the load balancer.\n */\nTags?: Tag[]\nLoadBalancerArn?: string\n/**\n * The IDs of the subnets. You can specify only one subnet per Availability Zone. You must specify either subnets or subnet mappings, but not both.\n *  [Application Load Balancers] You must specify subnets from at least two Availability Zones. You can't specify Elastic IP addresses for your subnets.\n *  [Application Load Balancers on Outposts] You must specify one Outpost subnet.\n *  [Application Load Balancers on Local Zones] You can specify subnets from one or more Local Zones.\n *  [Network Load Balancers] You can specify subnets from one or more Availability Zones. You can specify one Elastic IP address per subnet if you need static IP addresses for your internet-facing load balancer. For internal load balancers, you can specify one private IP address per subnet from the IPv4 range of the subnet. For internet-facing load balancer, you can specify one IPv6 address per subnet.\n *  [Gateway Load Balancers] You can specify subnets from one or more Availability Zones. You can't specify Elastic IP addresses for your subnets.\n */\nSubnetMappings?: SubnetMapping[]\n/**\n * Indicates whether to evaluate inbound security group rules for traffic sent to a Network Load Balancer through privatelink. The default is ``on``.\n *  You can't configure this property on a Network Load Balancer unless you associated a security group with the load balancer when you created it.\n */\nEnforceSecurityGroupInboundRulesOnPrivateLinkTraffic?: string\n/**\n * The ID of the IPv4 IPAM pool.\n */\nIpv4IpamPoolId?: string\n}\n/**\n * Specifies an attribute for an Application Load Balancer, a Network Load Balancer, or a Gateway Load Balancer.\n */\nexport interface LoadBalancerAttribute {\n/**\n * The value of the attribute.\n */\nValue?: string\n/**\n * The name of the attribute.\n *  The following attributes are supported by all load balancers:\n *   +  ``deletion_protection.enabled`` - Indicates whether deletion protection is enabled. The value is ``true`` or ``false``. The default is ``false``.\n *   +  ``load_balancing.cross_zone.enabled`` - Indicates whether cross-zone load balancing is enabled. The possible values are ``true`` and ``false``. The default for Network Load Balancers and Gateway Load Balancers is ``false``. The default for Application Load Balancers is ``true``, and can't be changed.\n *   \n *  The following attributes are supported by both Application Load Balancers and Network Load Balancers:\n *   +  ``access_logs.s3.enabled`` - Indicates whether access logs are enabled. The value is ``true`` or ``false``. The default is ``false``.\n *   +  ``access_logs.s3.bucket`` - The name of the S3 bucket for the access logs. This attribute is required if access logs are enabled. The bucket must exist in the same region as the load balancer and have a bucket policy that grants Elastic Load Balancing permissions to write to the bucket.\n *   +  ``access_logs.s3.prefix`` - The prefix for the location in the S3 bucket for the access logs.\n *   +  ``ipv6.deny_all_igw_traffic`` - Blocks internet gateway (IGW) access to the load balancer. It is set to ``false`` for internet-facing load balancers and ``true`` for internal load balancers, preventing unintended access to your internal load balancer through an internet gateway.\n *   +  ``zonal_shift.config.enabled`` - Indicates whether zonal shift is enabled. The possible values are ``true`` and ``false``. The default is ``false``.\n *   \n *  The following attributes are supported by only Application Load Balancers:\n *   +  ``idle_timeout.timeout_seconds`` - The idle timeout value, in seconds. The valid range is 1-4000 seconds. The default is 60 seconds.\n *   +  ``client_keep_alive.seconds`` - The client keep alive value, in seconds. The valid range is 60-604800 seconds. The default is 3600 seconds.\n *   +  ``connection_logs.s3.enabled`` - Indicates whether connection logs are enabled. The value is ``true`` or ``false``. The default is ``false``.\n *   +  ``connection_logs.s3.bucket`` - The name of the S3 bucket for the connection logs. This attribute is required if connection logs are enabled. The bucket must exist in the same region as the load balancer and have a bucket policy that grants Elastic Load Balancing permissions to write to the bucket.\n *   +  ``connection_logs.s3.prefix`` - The prefix for the location in the S3 bucket for the connection logs.\n *   +  ``routing.http.desync_mitigation_mode`` - Determines how the load balancer handles requests that might pose a security risk to your application. The possible values are ``monitor``, ``defensive``, and ``strictest``. The default is ``defensive``.\n *   +  ``routing.http.drop_invalid_header_fields.enabled`` - Indicates whether HTTP headers with invalid header fields are removed by the load balancer (``true``) or routed to targets (``false``). The default is ``false``.\n *   +  ``routing.http.preserve_host_header.enabled`` - Indicates whether the Application Load Balancer should preserve the ``Host`` header in the HTTP request and send it to the target without any change. The possible values are ``true`` and ``false``. The default is ``false``.\n *   +  ``routing.http.x_amzn_tls_version_and_cipher_suite.enabled`` - Indicates whether the two headers (``x-amzn-tls-version`` and ``x-amzn-tls-cipher-suite``), which contain information about the negotiated TLS version and cipher suite, are added to the client request before sending it to the target. The ``x-amzn-tls-version`` header has information about the TLS protocol version negotiated with the client, and the ``x-amzn-tls-cipher-suite`` header has information about the cipher suite negotiated with the client. Both headers are in OpenSSL format. The possible values for the attribute are ``true`` and ``false``. The default is ``false``.\n *   +  ``routing.http.xff_client_port.enabled`` - Indicates whether the ``X-Forwarded-For`` header should preserve the source port that the client used to connect to the load balancer. The possible values are ``true`` and ``false``. The default is ``false``.\n *   +  ``routing.http.xff_header_processing.mode`` - Enables you to modify, preserve, or remove the ``X-Forwarded-For`` header in the HTTP request before the Application Load Balancer sends the request to the target. The possible values are ``append``, ``preserve``, and ``remove``. The default is ``append``.\n *   +  If the value is ``append``, the Application Load Balancer adds the client IP address (of the last hop) to the ``X-Forwarded-For`` header in the HTTP request before it sends it to targets.\n *   +  If the value is ``preserve`` the Application Load Balancer preserves the ``X-Forwarded-For`` header in the HTTP request, and sends it to targets without any change.\n *   +  If the value is ``remove``, the Application Load Balancer removes the ``X-Forwarded-For`` header in the HTTP request before it sends it to targets.\n *   \n *   +  ``routing.http2.enabled`` - Indicates whether HTTP/2 is enabled. The possible values are ``true`` and ``false``. The default is ``true``. Elastic Load Balancing requires that message header names contain only alphanumeric characters and hyphens.\n *   +  ``waf.fail_open.enabled`` - Indicates whether to allow a WAF-enabled load balancer to route requests to targets if it is unable to forward the request to AWS WAF. The possible values are ``true`` and ``false``. The default is ``false``.\n *   \n *  The following attributes are supported by only Network Load Balancers:\n *   +  ``dns_record.client_routing_policy`` - Indicates how traffic is distributed among the load balancer Availability Zones. The possible values are ``availability_zone_affinity`` with 100 percent zonal affinity, ``partial_availability_zone_affinity`` with 85 percent zonal affinity, and ``any_availability_zone`` with 0 percent zonal affinity.\n */\nKey?: string\n}\n/**\n * The minimum capacity for a load balancer.\n */\nexport interface MinimumLoadBalancerCapacity {\n/**\n * The number of capacity units.\n */\nCapacityUnits: number\n}\n/**\n * Information about a tag.\n */\nexport interface Tag {\n/**\n * The value of the tag.\n */\nValue?: string\n/**\n * The key of the tag.\n */\nKey: string\n}\n/**\n * Specifies a subnet for a load balancer.\n */\nexport interface SubnetMapping {\n/**\n * The ID of the subnet.\n */\nSubnetId: string\n/**\n * [Network Load Balancers] The allocation ID of the Elastic IP address for an internet-facing load balancer.\n */\nAllocationId?: string\n/**\n * [Network Load Balancers] The private IPv4 address for an internal load balancer.\n */\nPrivateIPv4Address?: string\n/**\n * [Network Load Balancers] The IPv6 address.\n */\nIPv6Address?: string\n/**\n * [Network Load Balancers with UDP listeners] The IPv6 prefix to use for source NAT. Specify an IPv6 prefix (/80 netmask) from the subnet CIDR block or ``auto_assigned`` to use an IPv6 prefix selected at random from the subnet CIDR block.\n */\nSourceNatIpv6Prefix?: string\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-elasticloadbalancingv2-loadbalancer.js","sourceRoot":"","sources":["aws-elasticloadbalancingv2-loadbalancer.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Specifies an Application Load Balancer, a Network Load Balancer, or a Gateway Load Balancer.\n */\nexport interface _AWS_ELASTICLOADBALANCINGV2_LOADBALANCER {\n/**\n * The IP address type. Internal load balancers must use ``ipv4``.\n *  [Application Load Balancers] The possible values are ``ipv4`` (IPv4 addresses), ``dualstack`` (IPv4 and IPv6 addresses), and ``dualstack-without-public-ipv4`` (public IPv6 addresses and private IPv4 and IPv6 addresses).\n *  Application Load Balancer authentication supports IPv4 addresses only when connecting to an Identity Provider (IdP) or Amazon Cognito endpoint. Without a public IPv4 address the load balancer can't complete the authentication process, resulting in HTTP 500 errors.\n *  [Network Load Balancers and Gateway Load Balancers] The possible values are ``ipv4`` (IPv4 addresses) and ``dualstack`` (IPv4 and IPv6 addresses).\n */\nIpAddressType?: string\n/**\n * [Network Load Balancers with UDP listeners] Indicates whether to use an IPv6 prefix from each subnet for source NAT. The IP address type must be ``dualstack``. The default value is ``off``.\n */\nEnablePrefixForIpv6SourceNat?: string\n/**\n * [Application Load Balancers and Network Load Balancers] The IDs of the security groups for the load balancer.\n */\nSecurityGroups?: string[]\n/**\n * The load balancer attributes. Attributes that you do not modify retain their current values.\n */\nLoadBalancerAttributes?: LoadBalancerAttribute[]\nMinimumLoadBalancerCapacity?: MinimumLoadBalancerCapacity\n/**\n * The nodes of an Internet-facing load balancer have public IP addresses. The DNS name of an Internet-facing load balancer is publicly resolvable to the public IP addresses of the nodes. Therefore, Internet-facing load balancers can route requests from clients over the internet.\n *  The nodes of an internal load balancer have only private IP addresses. The DNS name of an internal load balancer is publicly resolvable to the private IP addresses of the nodes. Therefore, internal load balancers can route requests only from clients with access to the VPC for the load balancer.\n *  The default is an Internet-facing load balancer.\n *  You can't specify a scheme for a Gateway Load Balancer.\n */\nScheme?: string\nDNSName?: string\n/**\n * The name of the load balancer. This name must be unique per region per account, can have a maximum of 32 characters, must contain only alphanumeric characters or hyphens, must not begin or end with a hyphen, and must not begin with \"internal-\".\n *  If you don't specify a name, AWS CloudFormation generates a unique physical ID for the load balancer. If you specify a name, you cannot perform updates that require replacement of this resource, but you can perform other updates. To replace the resource, specify a new name.\n */\nName?: string\nLoadBalancerName?: string\nLoadBalancerFullName?: string\n/**\n * The IDs of the subnets. You can specify only one subnet per Availability Zone. You must specify either subnets or subnet mappings, but not both. To specify an Elastic IP address, specify subnet mappings instead of subnets.\n *  [Application Load Balancers] You must specify subnets from at least two Availability Zones.\n *  [Application Load Balancers on Outposts] You must specify one Outpost subnet.\n *  [Application Load Balancers on Local Zones] You can specify subnets from one or more Local Zones.\n *  [Network Load Balancers and Gateway Load Balancers] You can specify subnets from one or more Availability Zones.\n */\nSubnets?: string[]\n/**\n * The type of load balancer. The default is ``application``.\n */\nType?: string\nCanonicalHostedZoneID?: string\n/**\n * The tags to assign to the load balancer.\n */\nTags?: Tag[]\nLoadBalancerArn?: string\n/**\n * The IDs of the subnets. You can specify only one subnet per Availability Zone. You must specify either subnets or subnet mappings, but not both.\n *  [Application Load Balancers] You must specify subnets from at least two Availability Zones. You can't specify Elastic IP addresses for your subnets.\n *  [Application Load Balancers on Outposts] You must specify one Outpost subnet.\n *  [Application Load Balancers on Local Zones] You can specify subnets from one or more Local Zones.\n *  [Network Load Balancers] You can specify subnets from one or more Availability Zones. You can specify one Elastic IP address per subnet if you need static IP addresses for your internet-facing load balancer. For internal load balancers, you can specify one private IP address per subnet from the IPv4 range of the subnet. For internet-facing load balancer, you can specify one IPv6 address per subnet.\n *  [Gateway Load Balancers] You can specify subnets from one or more Availability Zones. You can't specify Elastic IP addresses for your subnets.\n */\nSubnetMappings?: SubnetMapping[]\n/**\n * Indicates whether to evaluate inbound security group rules for traffic sent to a Network Load Balancer through privatelink. The default is ``on``.\n *  You can't configure this property on a Network Load Balancer unless you associated a security group with the load balancer when you created it.\n */\nEnforceSecurityGroupInboundRulesOnPrivateLinkTraffic?: string\n/**\n * The ID of the IPv4 IPAM pool.\n */\nIpv4IpamPoolId?: string\n}\n/**\n * Specifies an attribute for an Application Load Balancer, a Network Load Balancer, or a Gateway Load Balancer.\n */\nexport interface LoadBalancerAttribute {\n/**\n * The value of the attribute.\n */\nValue?: string\n/**\n * The name of the attribute.\n *  The following attributes are supported by all load balancers:\n *   +  ``deletion_protection.enabled`` - Indicates whether deletion protection is enabled. The value is ``true`` or ``false``. The default is ``false``.\n *   +  ``load_balancing.cross_zone.enabled`` - Indicates whether cross-zone load balancing is enabled. The possible values are ``true`` and ``false``. The default for Network Load Balancers and Gateway Load Balancers is ``false``. The default for Application Load Balancers is ``true``, and can't be changed.\n *   \n *  The following attributes are supported by both Application Load Balancers and Network Load Balancers:\n *   +  ``access_logs.s3.enabled`` - Indicates whether access logs are enabled. The value is ``true`` or ``false``. The default is ``false``.\n *   +  ``access_logs.s3.bucket`` - The name of the S3 bucket for the access logs. This attribute is required if access logs are enabled. The bucket must exist in the same region as the load balancer and have a bucket policy that grants Elastic Load Balancing permissions to write to the bucket.\n *   +  ``access_logs.s3.prefix`` - The prefix for the location in the S3 bucket for the access logs.\n *   +  ``ipv6.deny_all_igw_traffic`` - Blocks internet gateway (IGW) access to the load balancer. It is set to ``false`` for internet-facing load balancers and ``true`` for internal load balancers, preventing unintended access to your internal load balancer through an internet gateway.\n *   +  ``zonal_shift.config.enabled`` - Indicates whether zonal shift is enabled. The possible values are ``true`` and ``false``. The default is ``false``.\n *   \n *  The following attributes are supported by only Application Load Balancers:\n *   +  ``idle_timeout.timeout_seconds`` - The idle timeout value, in seconds. The valid range is 1-4000 seconds. The default is 60 seconds.\n *   +  ``client_keep_alive.seconds`` - The client keep alive value, in seconds. The valid range is 60-604800 seconds. The default is 3600 seconds.\n *   +  ``connection_logs.s3.enabled`` - Indicates whether connection logs are enabled. The value is ``true`` or ``false``. The default is ``false``.\n *   +  ``connection_logs.s3.bucket`` - The name of the S3 bucket for the connection logs. This attribute is required if connection logs are enabled. The bucket must exist in the same region as the load balancer and have a bucket policy that grants Elastic Load Balancing permissions to write to the bucket.\n *   +  ``connection_logs.s3.prefix`` - The prefix for the location in the S3 bucket for the connection logs.\n *   +  ``routing.http.desync_mitigation_mode`` - Determines how the load balancer handles requests that might pose a security risk to your application. The possible values are ``monitor``, ``defensive``, and ``strictest``. The default is ``defensive``.\n *   +  ``routing.http.drop_invalid_header_fields.enabled`` - Indicates whether HTTP headers with invalid header fields are removed by the load balancer (``true``) or routed to targets (``false``). The default is ``false``.\n *   +  ``routing.http.preserve_host_header.enabled`` - Indicates whether the Application Load Balancer should preserve the ``Host`` header in the HTTP request and send it to the target without any change. The possible values are ``true`` and ``false``. The default is ``false``.\n *   +  ``routing.http.x_amzn_tls_version_and_cipher_suite.enabled`` - Indicates whether the two headers (``x-amzn-tls-version`` and ``x-amzn-tls-cipher-suite``), which contain information about the negotiated TLS version and cipher suite, are added to the client request before sending it to the target. The ``x-amzn-tls-version`` header has information about the TLS protocol version negotiated with the client, and the ``x-amzn-tls-cipher-suite`` header has information about the cipher suite negotiated with the client. Both headers are in OpenSSL format. The possible values for the attribute are ``true`` and ``false``. The default is ``false``.\n *   +  ``routing.http.xff_client_port.enabled`` - Indicates whether the ``X-Forwarded-For`` header should preserve the source port that the client used to connect to the load balancer. The possible values are ``true`` and ``false``. The default is ``false``.\n *   +  ``routing.http.xff_header_processing.mode`` - Enables you to modify, preserve, or remove the ``X-Forwarded-For`` header in the HTTP request before the Application Load Balancer sends the request to the target. The possible values are ``append``, ``preserve``, and ``remove``. The default is ``append``.\n *   +  If the value is ``append``, the Application Load Balancer adds the client IP address (of the last hop) to the ``X-Forwarded-For`` header in the HTTP request before it sends it to targets.\n *   +  If the value is ``preserve`` the Application Load Balancer preserves the ``X-Forwarded-For`` header in the HTTP request, and sends it to targets without any change.\n *   +  If the value is ``remove``, the Application Load Balancer removes the ``X-Forwarded-For`` header in the HTTP request before it sends it to targets.\n *   \n *   +  ``routing.http2.enabled`` - Indicates whether HTTP/2 is enabled. The possible values are ``true`` and ``false``. The default is ``true``. Elastic Load Balancing requires that message header names contain only alphanumeric characters and hyphens.\n *   +  ``waf.fail_open.enabled`` - Indicates whether to allow a WAF-enabled load balancer to route requests to targets if it is unable to forward the request to AWS WAF. The possible values are ``true`` and ``false``. The default is ``false``.\n *   \n *  The following attributes are supported by only Network Load Balancers:\n *   +  ``dns_record.client_routing_policy`` - Indicates how traffic is distributed among the load balancer Availability Zones. The possible values are ``availability_zone_affinity`` with 100 percent zonal affinity, ``partial_availability_zone_affinity`` with 85 percent zonal affinity, and ``any_availability_zone`` with 0 percent zonal affinity.\n */\nKey?: string\n}\n/**\n * The minimum capacity for a load balancer.\n */\nexport interface MinimumLoadBalancerCapacity {\n/**\n * The number of capacity units.\n */\nCapacityUnits: number\n}\n/**\n * Information about a tag.\n */\nexport interface Tag {\n/**\n * The value of the tag.\n */\nValue?: string\n/**\n * The key of the tag.\n */\nKey: string\n}\n/**\n * Specifies a subnet for a load balancer.\n */\nexport interface SubnetMapping {\n/**\n * The ID of the subnet.\n */\nSubnetId: string\n/**\n * [Network Load Balancers] The allocation ID of the Elastic IP address for an internet-facing load balancer.\n */\nAllocationId?: string\n/**\n * [Network Load Balancers] The private IPv4 address for an internal load balancer.\n */\nPrivateIPv4Address?: string\n/**\n * [Network Load Balancers] The IPv6 address.\n */\nIPv6Address?: string\n/**\n * [Network Load Balancers with UDP listeners] The IPv6 prefix to use for source NAT. Specify an IPv6 prefix (/80 netmask) from the subnet CIDR block or ``auto_assigned`` to use an IPv6 prefix selected at random from the subnet CIDR block.\n */\nSourceNatIpv6Prefix?: string\n}\n"]}

package/lib/types/cfn-resource-types/aws-entityresolution-matchingworkflow.d.ts

@@ -78,6 +78,7 @@ export interface OutputAttribute {
 export interface ResolutionTechniques {
     ResolutionType?: ResolutionType;
     RuleBasedProperties?: RuleBasedProperties;
+    RuleConditionProperties?: RuleConditionProperties;
     ProviderProperties?: ProviderProperties;
 }
 export interface RuleBasedProperties {
@@ -97,6 +98,17 @@ export interface Rule {
      */
     MatchingKeys: AttributeName[];
 }
+export interface RuleConditionProperties {
+    /**
+     * @minItems 1
+     * @maxItems 15
+     */
+    Rules: RuleCondition[];
+}
+export interface RuleCondition {
+    RuleName?: AttributeName;
+    Condition?: string;
+}
 export interface ProviderProperties {
     /**
      * Arn of the Provider service being used.

package/lib/types/cfn-resource-types/aws-entityresolution-matchingworkflow.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXdzLWVudGl0eXJlc29sdXRpb24tbWF0Y2hpbmd3b3JrZmxvdy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImF3cy1lbnRpdHlyZXNvbHV0aW9uLW1hdGNoaW5nd29ya2Zsb3cudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIEF0dHJpYnV0ZU5hbWUgPSBzdHJpbmdcbmV4cG9ydCB0eXBlIEtNU0FybiA9IHN0cmluZ1xuZXhwb3J0IHR5cGUgUmVzb2x1dGlvblR5cGUgPSAoXCJSVUxFX01BVENISU5HXCIgfCBcIk1MX01BVENISU5HXCIgfCBcIlBST1ZJREVSXCIpXG4vKipcbiAqIFRoZSBkZWZhdWx0IE1hdGNoaW5nV29ya2Zsb3cgYXJuXG4gKi9cbmV4cG9ydCB0eXBlIE1hdGNoaW5nV29ya2Zsb3dBcm4gPSBzdHJpbmdcbi8qKlxuICogVGhlIHRpbWUgb2YgdGhpcyBNYXRjaGluZ1dvcmtmbG93IGdvdCBjcmVhdGVkXG4gKi9cbmV4cG9ydCB0eXBlIENyZWF0ZWRBdCA9IHN0cmluZ1xuLyoqXG4gKiBUaGUgdGltZSBvZiB0aGlzIE1hdGNoaW5nV29ya2Zsb3cgZ290IGxhc3QgdXBkYXRlZCBhdFxuICovXG5leHBvcnQgdHlwZSBVcGRhdGVkQXQgPSBzdHJpbmdcblxuLyoqXG4gKiBNYXRjaGluZ1dvcmtmbG93IGRlZmluZWQgaW4gQVdTIEVudGl0eSBSZXNvbHV0aW9uIHNlcnZpY2VcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBfQVdTX0VOVElUWVJFU09MVVRJT05fTUFUQ0hJTkdXT1JLRkxPVyB7XG4vKipcbiAqIFRoZSBuYW1lIG9mIHRoZSBNYXRjaGluZ1dvcmtmbG93XG4gKi9cbldvcmtmbG93TmFtZTogc3RyaW5nXG4vKipcbiAqIFRoZSBkZXNjcmlwdGlvbiBvZiB0aGUgTWF0Y2hpbmdXb3JrZmxvd1xuICovXG5EZXNjcmlwdGlvbj86IHN0cmluZ1xuLyoqXG4gKiBAbWluSXRlbXMgMVxuICogQG1heEl0ZW1zIDIwXG4gKi9cbklucHV0U291cmNlQ29uZmlnOiBJbnB1dFNvdXJjZVtdXG4vKipcbiAqIEBtaW5JdGVtcyAxXG4gKiBAbWF4SXRlbXMgMVxuICovXG5PdXRwdXRTb3VyY2VDb25maWc6IE91dHB1dFNvdXJjZVtdXG5SZXNvbHV0aW9uVGVjaG5pcXVlczogUmVzb2x1dGlvblRlY2huaXF1ZXNcblJvbGVBcm46IHN0cmluZ1xuLyoqXG4gKiBAbWluSXRlbXMgMFxuICogQG1heEl0ZW1zIDIwMFxuICovXG5UYWdzPzogVGFnW11cbldvcmtmbG93QXJuPzogTWF0Y2hpbmdXb3JrZmxvd0FyblxuQ3JlYXRlZEF0PzogQ3JlYXRlZEF0XG5VcGRhdGVkQXQ/OiBVcGRhdGVkQXRcbkluY3JlbWVudGFsUnVuQ29uZmlnPzogSW5jcmVtZW50YWxSdW5Db25maWdcbn1cbmV4cG9ydCBpbnRlcmZhY2UgSW5wdXRTb3VyY2Uge1xuLyoqXG4gKiBBbiBHbHVlIHRhYmxlIEFSTiBmb3IgdGhlIGlucHV0IHNvdXJjZSB0YWJsZVxuICovXG5JbnB1dFNvdXJjZUFSTjogc3RyaW5nXG4vKipcbiAqIFRoZSBTY2hlbWFNYXBwaW5nIGFybiBhc3NvY2lhdGVkIHdpdGggdGhlIFNjaGVtYVxuICovXG5TY2hlbWFBcm46IHN0cmluZ1xuQXBwbHlOb3JtYWxpemF0aW9uPzogYm9vbGVhblxufVxuZXhwb3J0IGludGVyZmFjZSBPdXRwdXRTb3VyY2Uge1xuLyoqXG4gKiBUaGUgUzMgcGF0aCB0byB3aGljaCBFbnRpdHkgUmVzb2x1dGlvbiB3aWxsIHdyaXRlIHRoZSBvdXRwdXQgdGFibGVcbiAqL1xuT3V0cHV0UzNQYXRoOiBzdHJpbmdcbi8qKlxuICogQG1pbkl0ZW1zIDBcbiAqIEBtYXhJdGVtcyA3NTBcbiAqL1xuT3V0cHV0OiBPdXRwdXRBdHRyaWJ1dGVbXVxuS01TQXJuPzogS01TQXJuXG5BcHBseU5vcm1hbGl6YXRpb24/OiBib29sZWFuXG59XG5leHBvcnQgaW50ZXJmYWNlIE91dHB1dEF0dHJpYnV0ZSB7XG5OYW1lOiBBdHRyaWJ1dGVOYW1lXG5IYXNoZWQ/OiBib29sZWFuXG59XG5leHBvcnQgaW50ZXJmYWNlIFJlc29sdXRpb25UZWNobmlxdWVzIHtcblJlc29sdXRpb25UeXBlPzogUmVzb2x1dGlvblR5cGVcblJ1bGVCYXNlZFByb3BlcnRpZXM/OiBSdWxlQmFzZWRQcm9wZXJ0aWVzXG5SdWxlQ29uZGl0aW9uUHJvcGVydGllcz86IFJ1bGVDb25kaXRpb25Qcm9wZXJ0aWVzXG5Qcm92aWRlclByb3BlcnRpZXM/OiBQcm92aWRlclByb3BlcnRpZXNcbn1cbmV4cG9ydCBpbnRlcmZhY2UgUnVsZUJhc2VkUHJvcGVydGllcyB7XG4vKipcbiAqIEBtaW5JdGVtcyAxXG4gKiBAbWF4SXRlbXMgMTVcbiAqL1xuUnVsZXM6IFJ1bGVbXVxuQXR0cmlidXRlTWF0Y2hpbmdNb2RlbDogKFwiT05FX1RPX09ORVwiIHwgXCJNQU5ZX1RPX01BTllcIilcbk1hdGNoUHVycG9zZT86IChcIklERU5USUZJRVJfR0VORVJBVElPTlwiIHwgXCJJTkRFWElOR1wiKVxufVxuZXhwb3J0IGludGVyZmFjZSBSdWxlIHtcblJ1bGVOYW1lOiBzdHJpbmdcbi8qKlxuICogQG1pbkl0ZW1zIDFcbiAqIEBtYXhJdGVtcyAxNVxuICovXG5NYXRjaGluZ0tleXM6IEF0dHJpYnV0ZU5hbWVbXVxufVxuZXhwb3J0IGludGVyZmFjZSBSdWxlQ29uZGl0aW9uUHJvcGVydGllcyB7XG4vKipcbiAqIEBtaW5JdGVtcyAxXG4gKiBAbWF4SXRlbXMgMTVcbiAqL1xuUnVsZXM6IFJ1bGVDb25kaXRpb25bXVxufVxuZXhwb3J0IGludGVyZmFjZSBSdWxlQ29uZGl0aW9uIHtcblJ1bGVOYW1lPzogQXR0cmlidXRlTmFtZVxuQ29uZGl0aW9uPzogc3RyaW5nXG59XG5leHBvcnQgaW50ZXJmYWNlIFByb3ZpZGVyUHJvcGVydGllcyB7XG4vKipcbiAqIEFybiBvZiB0aGUgUHJvdmlkZXIgc2VydmljZSBiZWluZyB1c2VkLlxuICovXG5Qcm92aWRlclNlcnZpY2VBcm46IHN0cmluZ1xuLyoqXG4gKiBBZGRpdGlvbmFsIFByb3ZpZGVyIGNvbmZpZ3VyYXRpb24gdGhhdCB3b3VsZCBiZSByZXF1aXJlZCBmb3IgdGhlIHByb3ZpZGVyIHNlcnZpY2UuIFRoZSBDb25maWd1cmF0aW9uIG11c3QgYmUgaW4gSlNPTiBzdHJpbmcgZm9ybWF0XG4gKi9cblByb3ZpZGVyQ29uZmlndXJhdGlvbj86IHtcbi8qKlxuICogVGhpcyBpbnRlcmZhY2Ugd2FzIHJlZmVyZW5jZWQgYnkgYHVuZGVmaW5lZGAncyBKU09OLVNjaGVtYSBkZWZpbml0aW9uXG4gKiB2aWEgdGhlIGBwYXR0ZXJuUHJvcGVydHlgIFwiXi4rJFwiLlxuICovXG5bazogc3RyaW5nXTogc3RyaW5nXG59XG5JbnRlcm1lZGlhdGVTb3VyY2VDb25maWd1cmF0aW9uPzogSW50ZXJtZWRpYXRlU291cmNlQ29uZmlndXJhdGlvblxufVxuZXhwb3J0IGludGVyZmFjZSBJbnRlcm1lZGlhdGVTb3VyY2VDb25maWd1cmF0aW9uIHtcbi8qKlxuICogVGhlIHMzIHBhdGggdGhhdCB3b3VsZCBiZSB1c2VkIHRvIHN0YWdlIHRoZSBpbnRlcm1lZGlhdGUgZGF0YSBiZWluZyBnZW5lcmF0ZWQgZHVyaW5nIHdvcmtmbG93IGV4ZWN1dGlvbi5cbiAqL1xuSW50ZXJtZWRpYXRlUzNQYXRoOiBzdHJpbmdcbn1cbi8qKlxuICogQSBrZXktdmFsdWUgcGFpciB0byBhc3NvY2lhdGUgd2l0aCBhIHJlc291cmNlXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgVGFnIHtcbi8qKlxuICogVGhlIGtleSBuYW1lIG9mIHRoZSB0YWcuIFlvdSBjYW4gc3BlY2lmeSBhIHZhbHVlIHRoYXQgaXMgMSB0byAxMjggVW5pY29kZSBjaGFyYWN0ZXJzIGluIGxlbmd0aCBhbmQgY2Fubm90IGJlIHByZWZpeGVkIHdpdGggYXdzOi4gWW91IGNhbiB1c2UgYW55IG9mIHRoZSBmb2xsb3dpbmcgY2hhcmFjdGVyczogdGhlIHNldCBvZiBVbmljb2RlIGxldHRlcnMsIGRpZ2l0cywgd2hpdGVzcGFjZSwgXywgLiwgLywgPSwgKywgYW5kIC0uXG4gKi9cbktleTogc3RyaW5nXG4vKipcbiAqIFRoZSB2YWx1ZSBmb3IgdGhlIHRhZy4gWW91IGNhbiBzcGVjaWZ5IGEgdmFsdWUgdGhhdCBpcyAwIHRvIDI1NiBVbmljb2RlIGNoYXJhY3RlcnMgaW4gbGVuZ3RoIGFuZCBjYW5ub3QgYmUgcHJlZml4ZWQgd2l0aCBhd3M6LiBZb3UgY2FuIHVzZSBhbnkgb2YgdGhlIGZvbGxvd2luZyBjaGFyYWN0ZXJzOiB0aGUgc2V0IG9mIFVuaWNvZGUgbGV0dGVycywgZGlnaXRzLCB3aGl0ZXNwYWNlLCBfLCAuLCAvLCA9LCArLCBhbmQgLS5cbiAqL1xuVmFsdWU6IHN0cmluZ1xufVxuZXhwb3J0IGludGVyZmFjZSBJbmNyZW1lbnRhbFJ1bkNvbmZpZyB7XG5JbmNyZW1lbnRhbFJ1blR5cGU6IFwiSU1NRURJQVRFXCJcbn1cbiJdfQ==

package/lib/types/cfn-resource-types/aws-glue-job.d.ts

@@ -37,7 +37,7 @@ export interface _AWS_GLUE_JOB {
     /**
      * TThe type of predefined worker that is allocated when a job runs.
      */
-    WorkerType?: ("Standard" | "G.1X" | "G.2X" | "G.025X" | "G.4X" | "G.8X" | "Z.2X");
+    WorkerType?: ("Standard" | "G.1X" | "G.2X" | "G.025X" | "G.4X" | "G.8X" | "Z.2X" | "G.12X" | "G.16X" | "R.1X" | "R.2X" | "R.4X" | "R.8X");
     /**
      * Indicates whether the job is run with a standard or flexible execution class.
      */

package/lib/types/cfn-resource-types/aws-glue-job.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/cfn-resource-types/aws-iotsitewise-computationmodel.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Resource schema for AWS::IoTSiteWise::ComputationModel.
+ */
+export interface _AWS_IOTSITEWISE_COMPUTATIONMODEL {
+    /**
+     * The ID of the computation model.
+     */
+    ComputationModelId?: string;
+    /**
+     * The ARN of the computation model.
+     */
+    ComputationModelArn?: string;
+    /**
+     * The name of the computation model.
+     */
+    ComputationModelName: string;
+    /**
+     * A description about the computation model.
+     */
+    ComputationModelDescription?: string;
+    ComputationModelConfiguration: ComputationModelConfiguration;
+    ComputationModelDataBinding: ComputationModelDataBinding;
+    /**
+     * An array of key-value pairs to apply to this resource.
+     */
+    Tags?: Tag[];
+}
+/**
+ * The configuration for the computation model.
+ */
+export interface ComputationModelConfiguration {
+    AnomalyDetection?: AnomalyDetectionComputationModelConfiguration;
+}
+/**
+ * Contains configuration for anomaly detection computation model.
+ */
+export interface AnomalyDetectionComputationModelConfiguration {
+    /**
+     * Input properties for anomaly detection.
+     */
+    InputProperties: string;
+    /**
+     * Result property for anomaly detection.
+     */
+    ResultProperty: string;
+}
+/**
+ * The data binding for the computation model.
+ */
+export interface ComputationModelDataBinding {
+    [k: string]: ComputationModelDataBindingValue;
+}
+/**
+ * This interface was referenced by `ComputationModelDataBinding`'s JSON-Schema definition
+ * via the `patternProperty` "^[a-z][a-z0-9_]{0,63}$".
+ */
+export interface ComputationModelDataBindingValue {
+    AssetModelProperty?: AssetModelPropertyBindingValue;
+    AssetProperty?: AssetPropertyBindingValue;
+    /**
+     * Defines a list of computation model binding values.
+     */
+    List?: ComputationModelDataBindingValue[];
+}
+/**
+ * Defines an asset model property binding.
+ */
+export interface AssetModelPropertyBindingValue {
+    /**
+     * The ID of the asset model.
+     */
+    AssetModelId: string;
+    /**
+     * The ID of the asset model property.
+     */
+    PropertyId: string;
+}
+/**
+ * Defines an asset property binding.
+ */
+export interface AssetPropertyBindingValue {
+    /**
+     * The ID of the asset.
+     */
+    AssetId: string;
+    /**
+     * The ID of the asset property.
+     */
+    PropertyId: string;
+}
+export interface Tag {
+    Key: string;
+    Value: string;
+}

package/lib/types/cfn-resource-types/aws-iotsitewise-computationmodel.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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