cdk-docker-image-deployment 0.0.138 → 0.0.140

package/node_modules/aws-sdk/clients/glue.d.ts

@@ -2375,6 +2375,28 @@ declare namespace Glue {
     TableName: NameString;
   }
   export type CatalogGetterPageSize = number;
+  export interface CatalogHudiSource {
+    /**
+     * The name of the Hudi data source.
+     */
+    Name: NodeName;
+    /**
+     * The name of the database to read from.
+     */
+    Database: EnclosedInStringProperty;
+    /**
+     * The name of the table in the database to read from.
+     */
+    Table: EnclosedInStringProperty;
+    /**
+     * Specifies additional connection options.
+     */
+    AdditionalHudiOptions?: AdditionalOptions;
+    /**
+     * Specifies the data schema for the Hudi source.
+     */
+    OutputSchemas?: GlueSchemas;
+  }
   export type CatalogIdString = string;
   export interface CatalogImportStatus {
     /**
@@ -2755,6 +2777,26 @@ declare namespace Glue {
      * Specifies your data quality evaluation criteria.
      */
     EvaluateDataQuality?: EvaluateDataQuality;
+    /**
+     * Specifies a Hudi data source that is registered in the Glue Data Catalog. The Hudi data source must be stored in Amazon S3.
+     */
+    S3CatalogHudiSource?: S3CatalogHudiSource;
+    /**
+     * Specifies a Hudi data source that is registered in the Glue Data Catalog.
+     */
+    CatalogHudiSource?: CatalogHudiSource;
+    /**
+     * Specifies a Hudi data source stored in Amazon S3.
+     */
+    S3HudiSource?: S3HudiSource;
+    /**
+     * Specifies a target that writes to a Hudi data source in the Glue Data Catalog.
+     */
+    S3HudiCatalogTarget?: S3HudiCatalogTarget;
+    /**
+     * Specifies a target that writes to a Hudi data source in Amazon S3.
+     */
+    S3HudiDirectTarget?: S3HudiDirectTarget;
   }
   export type CodeGenConfigurationNodes = {[key: string]: CodeGenConfigurationNode};
   export interface CodeGenEdge {
@@ -7600,6 +7642,7 @@ declare namespace Glue {
   }
   export type GrokPattern = string;
   export type HashString = string;
+  export type HudiTargetCompressionType = "gzip"|"lzo"|"uncompressed"|"snappy"|string;
   export type IdString = string;
   export interface ImportCatalogToGlueRequest {
     /**
@@ -9964,6 +10007,28 @@ declare namespace Glue {
      */
     Id?: IntegerValue;
   }
+  export interface S3CatalogHudiSource {
+    /**
+     * The name of the Hudi data source.
+     */
+    Name: NodeName;
+    /**
+     * The name of the database to read from.
+     */
+    Database: EnclosedInStringProperty;
+    /**
+     * The name of the table in the database to read from.
+     */
+    Table: EnclosedInStringProperty;
+    /**
+     * Specifies additional connection options.
+     */
+    AdditionalHudiOptions?: AdditionalOptions;
+    /**
+     * Specifies the data schema for the Hudi source.
+     */
+    OutputSchemas?: GlueSchemas;
+  }
   export interface S3CatalogSource {
     /**
      * The name of the data store.
@@ -10176,6 +10241,80 @@ declare namespace Glue {
      */
     SchemaChangePolicy?: DirectSchemaChangePolicy;
   }
+  export interface S3HudiCatalogTarget {
+    /**
+     * The name of the data target.
+     */
+    Name: NodeName;
+    /**
+     * The nodes that are inputs to the data target.
+     */
+    Inputs: OneInput;
+    /**
+     * Specifies native partitioning using a sequence of keys.
+     */
+    PartitionKeys?: GlueStudioPathList;
+    /**
+     * The name of the table in the database to write to.
+     */
+    Table: EnclosedInStringProperty;
+    /**
+     * The name of the database to write to.
+     */
+    Database: EnclosedInStringProperty;
+    /**
+     * Specifies additional connection options for the connector.
+     */
+    AdditionalOptions: AdditionalOptions;
+    SchemaChangePolicy?: CatalogSchemaChangePolicy;
+  }
+  export interface S3HudiDirectTarget {
+    /**
+     * The name of the data target.
+     */
+    Name: NodeName;
+    /**
+     * The nodes that are inputs to the data target.
+     */
+    Inputs: OneInput;
+    /**
+     * The Amazon S3 path of your Hudi data source to write to.
+     */
+    Path: EnclosedInStringProperty;
+    /**
+     * Specifies how the data is compressed. This is generally not necessary if the data has a standard file extension. Possible values are "gzip" and "bzip").
+     */
+    Compression: HudiTargetCompressionType;
+    /**
+     * Specifies native partitioning using a sequence of keys.
+     */
+    PartitionKeys?: GlueStudioPathList;
+    /**
+     * Specifies the data output format for the target.
+     */
+    Format: TargetFormat;
+    AdditionalOptions: AdditionalOptions;
+    SchemaChangePolicy?: DirectSchemaChangePolicy;
+  }
+  export interface S3HudiSource {
+    /**
+     * The name of the Hudi source.
+     */
+    Name: NodeName;
+    /**
+     * A list of the Amazon S3 paths to read from.
+     */
+    Paths: EnclosedInStringProperties;
+    /**
+     * Specifies additional connection options.
+     */
+    AdditionalHudiOptions?: AdditionalOptions;
+    AdditionalOptions?: S3DirectSourceAdditionalOptions;
+    /**
+     * Specifies the data schema for the Hudi source.
+     */
+    OutputSchemas?: GlueSchemas;
+  }
   export interface S3JsonSource {
     /**
      * The name of the data store.
@@ -11498,7 +11637,7 @@ declare namespace Glue {
   }
   export type TagValue = string;
   export type TagsMap = {[key: string]: TagValue};
-  export type TargetFormat = "json"|"csv"|"avro"|"orc"|"parquet"|string;
+  export type TargetFormat = "json"|"csv"|"avro"|"orc"|"parquet"|"hudi"|string;
   export interface TaskRun {
     /**
      * The unique identifier for the transform.

package/node_modules/aws-sdk/clients/groundstation.d.ts

@@ -2,6 +2,7 @@ import {Request} from '../lib/request';
 import {Response} from '../lib/response';
 import {AWSError} from '../lib/error';
 import {Service} from '../lib/service';
+import {WaiterConfiguration} from '../lib/service';
 import {ServiceConfigurationOptions} from '../lib/service';
 import {ConfigBase as Config} from '../lib/config-base';
 interface Blob {}
@@ -251,6 +252,14 @@ declare class GroundStation extends Service {
    * Updates a mission profile. Updating a mission profile will not update the execution parameters for existing future contacts.
    */
   updateMissionProfile(callback?: (err: AWSError, data: GroundStation.Types.MissionProfileIdResponse) => void): Request<GroundStation.Types.MissionProfileIdResponse, AWSError>;
+  /**
+   * Waits for the contactScheduled state by periodically calling the underlying GroundStation.describeContactoperation every 5 seconds (at most 180 times). Waits until a contact has been scheduled
+   */
+  waitFor(state: "contactScheduled", params: GroundStation.Types.DescribeContactRequest & {$waiter?: WaiterConfiguration}, callback?: (err: AWSError, data: GroundStation.Types.DescribeContactResponse) => void): Request<GroundStation.Types.DescribeContactResponse, AWSError>;
+  /**
+   * Waits for the contactScheduled state by periodically calling the underlying GroundStation.describeContactoperation every 5 seconds (at most 180 times). Waits until a contact has been scheduled
+   */
+  waitFor(state: "contactScheduled", callback?: (err: AWSError, data: GroundStation.Types.DescribeContactResponse) => void): Request<GroundStation.Types.DescribeContactResponse, AWSError>;
 }
 declare namespace GroundStation {
   export type AWSRegion = string;
@@ -458,6 +467,14 @@ declare namespace GroundStation {
     tags?: TagsMap;
   }
   export interface CreateDataflowEndpointGroupRequest {
+    /**
+     * Amount of time, in seconds, after a contact ends for the contact to remain in a POSTPASS state. A CloudWatch event is emitted when the contact enters and exits the POSTPASS state.
+     */
+    contactPostPassDurationSeconds?: DataflowEndpointGroupDurationInSeconds;
+    /**
+     * Amount of time, in seconds, prior to contact start for the contact to remain in a PREPASS state. A CloudWatch event is emitted when the contact enters and exits the PREPASS state.
+     */
+    contactPrePassDurationSeconds?: DataflowEndpointGroupDurationInSeconds;
     /**
      * Endpoint details of each endpoint in the dataflow endpoint group.
      */
@@ -572,6 +589,7 @@ declare namespace GroundStation {
     dataflowEndpointRegion?: String;
   }
   export type DataflowEndpointGroupArn = string;
+  export type DataflowEndpointGroupDurationInSeconds = number;
   export interface DataflowEndpointGroupIdResponse {
     /**
      * UUID of a dataflow endpoint group.
@@ -938,6 +956,14 @@ declare namespace GroundStation {
     dataflowEndpointGroupId: Uuid;
   }
   export interface GetDataflowEndpointGroupResponse {
+    /**
+     * Amount of time, in seconds, after a contact ends for the contact to remain in a POSTPASS state. A CloudWatch event is emitted when the contact enters and exits the POSTPASS state.
+     */
+    contactPostPassDurationSeconds?: DataflowEndpointGroupDurationInSeconds;
+    /**
+     * Amount of time, in seconds, prior to contact start for the contact to remain in a PREPASS state. A CloudWatch event is emitted when the contact enters and exits the PREPASS state.
+     */
+    contactPrePassDurationSeconds?: DataflowEndpointGroupDurationInSeconds;
     /**
      * ARN of a dataflow endpoint group.
      */

package/node_modules/aws-sdk/clients/groundstation.js

@@ -9,6 +9,7 @@ Object.defineProperty(apiLoader.services['groundstation'], '2019-05-23', {
   get: function get() {
     var model = require('../apis/groundstation-2019-05-23.min.json');
     model.paginators = require('../apis/groundstation-2019-05-23.paginators.json').pagination;
+    model.waiters = require('../apis/groundstation-2019-05-23.waiters2.json').waiters;
     return model;
   },
   enumerable: true,

package/node_modules/aws-sdk/clients/medialive.d.ts

@@ -4801,6 +4801,10 @@ When a segmentation style of "maintainCadence" is selected and a segment is trun
      * Packet Identifier (PID) of the elementary video stream in the transport stream. Can be entered as a decimal or hexadecimal value.  Valid values are 32 (or 0x20)..8182 (or 0x1ff6).
      */
     VideoPid?: __string;
+    /**
+     * Defines the amount SCTE-35 preroll will be increased (in milliseconds) on the output. Preroll is the amount of time between the presence of a SCTE-35 indication in a transport stream and the PTS of the video frame it references. Zero means don't add pullup (it doesn't mean set the preroll to zero). Negative pullup is not supported, which means that you can't make the preroll shorter. Be aware that latency in the output will increase by the pullup amount.
+     */
+    Scte35PrerollPullupMilliseconds?: __doubleMin0Max5000;
   }
   export type M2tsTimedMetadataBehavior = "NO_PASSTHROUGH"|"PASSTHROUGH"|string;
   export type M3u8NielsenId3Behavior = "NO_PASSTHROUGH"|"PASSTHROUGH"|string;
@@ -7092,6 +7096,7 @@ If STANDARD channel, subnet IDs must be mapped to two unique availability zones
   export type __doubleMin0 = number;
   export type __doubleMin0Max1 = number;
   export type __doubleMin0Max100 = number;
+  export type __doubleMin0Max5000 = number;
   export type __doubleMin1 = number;
   export type __doubleMin1Max65535 = number;
   export type __doubleMinNegative59Max0 = number;

package/node_modules/aws-sdk/clients/opensearch.d.ts

@@ -20,11 +20,11 @@ declare class OpenSearch extends Service {
    */
   acceptInboundConnection(callback?: (err: AWSError, data: OpenSearch.Types.AcceptInboundConnectionResponse) => void): Request<OpenSearch.Types.AcceptInboundConnectionResponse, AWSError>;
   /**
-   * Attaches tags to an existing Amazon OpenSearch Service domain. Tags are a set of case-sensitive key-value pairs. An domain can have up to 10 tags. For more information, see  Tagging Amazon OpenSearch Service domains.
+   * Attaches tags to an existing Amazon OpenSearch Service domain. Tags are a set of case-sensitive key-value pairs. A domain can have up to 10 tags. For more information, see Tagging Amazon OpenSearch Service domains.
    */
   addTags(params: OpenSearch.Types.AddTagsRequest, callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>;
   /**
-   * Attaches tags to an existing Amazon OpenSearch Service domain. Tags are a set of case-sensitive key-value pairs. An domain can have up to 10 tags. For more information, see  Tagging Amazon OpenSearch Service domains.
+   * Attaches tags to an existing Amazon OpenSearch Service domain. Tags are a set of case-sensitive key-value pairs. A domain can have up to 10 tags. For more information, see Tagging Amazon OpenSearch Service domains.
    */
   addTags(callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>;
   /**
@@ -163,6 +163,14 @@ declare class OpenSearch extends Service {
    * Returns domain configuration information about the specified Amazon OpenSearch Service domains.
    */
   describeDomains(callback?: (err: AWSError, data: OpenSearch.Types.DescribeDomainsResponse) => void): Request<OpenSearch.Types.DescribeDomainsResponse, AWSError>;
+  /**
+   * Describes the progress of a pre-update dry run analysis on an Amazon OpenSearch Service domain. For more information, see Determining whether a change will cause a blue/green deployment.
+   */
+  describeDryRunProgress(params: OpenSearch.Types.DescribeDryRunProgressRequest, callback?: (err: AWSError, data: OpenSearch.Types.DescribeDryRunProgressResponse) => void): Request<OpenSearch.Types.DescribeDryRunProgressResponse, AWSError>;
+  /**
+   * Describes the progress of a pre-update dry run analysis on an Amazon OpenSearch Service domain. For more information, see Determining whether a change will cause a blue/green deployment.
+   */
+  describeDryRunProgress(callback?: (err: AWSError, data: OpenSearch.Types.DescribeDryRunProgressResponse) => void): Request<OpenSearch.Types.DescribeDryRunProgressResponse, AWSError>;
   /**
    * Lists all the inbound cross-cluster search connections for a destination (remote) Amazon OpenSearch Service domain. For more information, see Cross-cluster search for Amazon OpenSearch Service.
    */
@@ -994,7 +1002,7 @@ declare namespace OpenSearch {
   }
   export interface CreateVpcEndpointRequest {
     /**
-     * The Amazon Resource Name (ARN) of the domain to grant access to.
+     * The Amazon Resource Name (ARN) of the domain to create the endpoint for.
      */
     DomainArn: DomainArn;
     /**
@@ -1152,6 +1160,34 @@ declare namespace OpenSearch {
      */
     DomainStatusList: DomainStatusList;
   }
+  export interface DescribeDryRunProgressRequest {
+    /**
+     * The name of the domain.
+     */
+    DomainName: DomainName;
+    /**
+     * The unique identifier of the dry run.
+     */
+    DryRunId?: GUID;
+    /**
+     * Whether to include the configuration of the dry run in the response. The configuration specifies the updates that you're planning to make on the domain.
+     */
+    LoadDryRunConfig?: Boolean;
+  }
+  export interface DescribeDryRunProgressResponse {
+    /**
+     * The current status of the dry run, including any validation errors.
+     */
+    DryRunProgressStatus?: DryRunProgressStatus;
+    /**
+     * Details about the changes you're planning to make on the domain.
+     */
+    DryRunConfig?: DomainStatus;
+    /**
+     * The results of the dry run. 
+     */
+    DryRunResults?: DryRunResults;
+  }
   export interface DescribeInboundConnectionsRequest {
     /**
      *  A list of filters used to match properties for inbound cross-cluster connections.
@@ -1601,6 +1637,29 @@ declare namespace OpenSearch {
   export type DomainStatusList = DomainStatus[];
   export type Double = number;
   export type DryRun = boolean;
+  export type DryRunMode = "Basic"|"Verbose"|string;
+  export interface DryRunProgressStatus {
+    /**
+     * The unique identifier of the dry run.
+     */
+    DryRunId: GUID;
+    /**
+     * The current status of the dry run.
+     */
+    DryRunStatus: String;
+    /**
+     * The timestamp when the dry run was initiated.
+     */
+    CreationDate: String;
+    /**
+     * The timestamp when the dry run was last updated.
+     */
+    UpdateDate: String;
+    /**
+     * Any validation failures that occurred as a result of the dry run.
+     */
+    ValidationFailures?: ValidationFailures;
+  }
   export interface DryRunResults {
     /**
      *  Specifies the way in which OpenSearch Service will apply an update. Possible values are:    Blue/Green - The update requires a blue/green deployment.    DynamicUpdate - No blue/green deployment required    Undetermined - The domain is in the middle of an update and can't predict the deployment type. Try again after the update is complete.    None - The request doesn't include any configuration changes.  
@@ -2685,9 +2744,13 @@ declare namespace OpenSearch {
      */
     AutoTuneOptions?: AutoTuneOptions;
     /**
-     * This flag, when set to True, specifies whether the UpdateDomain request should return the results of validation check without actually applying the change.
+     * This flag, when set to True, specifies whether the UpdateDomain request should return the results of a dry run analysis without actually applying the change. A dry run determines what type of deployment the update will cause.
      */
     DryRun?: DryRun;
+    /**
+     * The type of dry run to perform.    Basic only returns the type of deployment (blue/green or dynamic) that the update will cause.    Verbose runs an additional check to validate the changes you're making. For more information, see Validating a domain update.  
+     */
+    DryRunMode?: DryRunMode;
   }
   export interface UpdateDomainConfigResponse {
     /**
@@ -2695,9 +2758,13 @@ declare namespace OpenSearch {
      */
     DomainConfig: DomainConfig;
     /**
-     * Results of a dry run performed in an update domain request.
+     * Results of the dry run performed in the update domain request.
      */
     DryRunResults?: DryRunResults;
+    /**
+     * The status of the dry run being performed on the domain, if any.
+     */
+    DryRunProgressStatus?: DryRunProgressStatus;
   }
   export interface UpdatePackageRequest {
     /**
@@ -2865,6 +2932,17 @@ declare namespace OpenSearch {
      */
     SecurityGroupIds?: StringList;
   }
+  export interface ValidationFailure {
+    /**
+     * The error code of the failure.
+     */
+    Code?: String;
+    /**
+     * A message corresponding to the failure.
+     */
+    Message?: String;
+  }
+  export type ValidationFailures = ValidationFailure[];
   export type ValueStringList = NonEmptyString[];
   export type VersionList = VersionString[];
   export interface VersionStatus {

package/node_modules/aws-sdk/clients/panorama.d.ts

@@ -20,11 +20,11 @@ declare class Panorama extends Service {
    */
   createApplicationInstance(callback?: (err: AWSError, data: Panorama.Types.CreateApplicationInstanceResponse) => void): Request<Panorama.Types.CreateApplicationInstanceResponse, AWSError>;
   /**
-   * Creates a job to run on one or more devices. A job can update a device's software or reboot it.
+   * Creates a job to run on a device. A job can update a device's software or reboot it.
    */
   createJobForDevices(params: Panorama.Types.CreateJobForDevicesRequest, callback?: (err: AWSError, data: Panorama.Types.CreateJobForDevicesResponse) => void): Request<Panorama.Types.CreateJobForDevicesResponse, AWSError>;
   /**
-   * Creates a job to run on one or more devices. A job can update a device's software or reboot it.
+   * Creates a job to run on a device. A job can update a device's software or reboot it.
    */
   createJobForDevices(callback?: (err: AWSError, data: Panorama.Types.CreateJobForDevicesResponse) => void): Request<Panorama.Types.CreateJobForDevicesResponse, AWSError>;
   /**
@@ -397,7 +397,7 @@ declare namespace Panorama {
   }
   export interface CreateJobForDevicesRequest {
     /**
-     * IDs of target devices.
+     * ID of target device.
      */
     DeviceIds: DeviceIdList;
     /**
@@ -1744,6 +1744,10 @@ declare namespace Panorama {
     NtpServerName?: NtpServerName;
   }
   export interface OTAJobConfig {
+    /**
+     * Whether to apply the update if it is a major version change.
+     */
+    AllowMajorVersionUpdate?: Boolean;
     /**
      * The target version of the device software.
      */

package/node_modules/aws-sdk/clients/sagemaker.d.ts

@@ -11525,9 +11525,16 @@ declare namespace SageMaker {
      * The configuration for the hyperparameter tuning resources, including the compute instances and storage volumes, used for training jobs launched by the tuning job. By default, storage volumes hold model artifacts and incremental states. Choose File for TrainingInputMode in the AlgorithmSpecification parameter to additionally store training data in the storage volume (optional).
      */
     HyperParameterTuningResourceConfig?: HyperParameterTuningResourceConfig;
+    /**
+     * An environment variable that you can pass into the SageMaker CreateTrainingJob API. You can use an existing environment variable from the training container or use your own. See Define metrics and variables for more information.  The maximum number of items specified for Map Entries refers to the maximum number of environment variables for each TrainingJobDefinition and also the maximum for the hyperparameter tuning job itself. That is, the sum of the number of environment variables for all the training job definitions can't exceed the maximum number specified. 
+     */
+    Environment?: HyperParameterTrainingJobEnvironmentMap;
   }
   export type HyperParameterTrainingJobDefinitionName = string;
   export type HyperParameterTrainingJobDefinitions = HyperParameterTrainingJobDefinition[];
+  export type HyperParameterTrainingJobEnvironmentKey = string;
+  export type HyperParameterTrainingJobEnvironmentMap = {[key: string]: HyperParameterTrainingJobEnvironmentValue};
+  export type HyperParameterTrainingJobEnvironmentValue = string;
   export type HyperParameterTrainingJobSummaries = HyperParameterTrainingJobSummary[];
   export interface HyperParameterTrainingJobSummary {
     /**
@@ -11586,7 +11593,7 @@ declare namespace SageMaker {
      */
     InstanceType: TrainingInstanceType;
     /**
-     * The number of instances of the type specified by InstanceType. Choose an instance count larger than 1 for distributed training algorithms. See SageMaker distributed training jobs for more informcration.
+     * The number of instances of the type specified by InstanceType. Choose an instance count larger than 1 for distributed training algorithms. See SageMaker distributed training jobs for more information.
      */
     InstanceCount: TrainingInstanceCount;
     /**
@@ -20849,7 +20856,7 @@ declare namespace SageMaker {
      */
     RetainAllVariantProperties?: Boolean;
     /**
-     * When you are updating endpoint resources with UpdateEndpointInput$RetainAllVariantProperties, whose value is set to true, ExcludeRetainedVariantProperties specifies the list of type VariantProperty to override with the values provided by EndpointConfig. If you don't specify a value for ExcludeAllVariantProperties, no variant properties are overridden. 
+     * When you are updating endpoint resources with UpdateEndpointInput$RetainAllVariantProperties, whose value is set to true, ExcludeRetainedVariantProperties specifies the list of type VariantProperty to override with the values provided by EndpointConfig. If you don't specify a value for ExcludeRetainedVariantProperties, no variant properties are overridden. 
      */
     ExcludeRetainedVariantProperties?: VariantPropertyList;
     /**

package/node_modules/aws-sdk/clients/wafv2.d.ts

@@ -316,11 +316,11 @@ declare class WAFV2 extends Service {
    */
   listWebACLs(callback?: (err: AWSError, data: WAFV2.Types.ListWebACLsResponse) => void): Request<WAFV2.Types.ListWebACLsResponse, AWSError>;
   /**
-   * Enables the specified LoggingConfiguration, to start logging from a web ACL, according to the configuration provided.   You can define one logging destination per web ACL.  You can access information about the traffic that WAF inspects using the following steps:   Create your logging destination. You can use an Amazon CloudWatch Logs log group, an Amazon Simple Storage Service (Amazon S3) bucket, or an Amazon Kinesis Data Firehose.  The name that you give the destination must start with aws-waf-logs-. Depending on the type of destination, you might need to configure additional settings or permissions.  For configuration requirements and pricing information for each destination type, see Logging web ACL traffic in the WAF Developer Guide.   Associate your logging destination to your web ACL using a PutLoggingConfiguration request.   When you successfully enable logging using a PutLoggingConfiguration request, WAF creates an additional role or policy that is required to write logs to the logging destination. For an Amazon CloudWatch Logs log group, WAF creates a resource policy on the log group. For an Amazon S3 bucket, WAF creates a bucket policy. For an Amazon Kinesis Data Firehose, WAF creates a service-linked role. For additional information about web ACL logging, see Logging web ACL traffic information in the WAF Developer Guide.  This operation completely replaces the mutable specifications that you already have for the logging configuration with the ones that you provide to this call. To modify the logging configuration, retrieve it by calling GetLoggingConfiguration, update the settings as needed, and then provide the complete logging configuration specification to this call. 
+   * Enables the specified LoggingConfiguration, to start logging from a web ACL, according to the configuration provided.   This operation completely replaces any mutable specifications that you already have for a logging configuration with the ones that you provide to this call.  To modify an existing logging configuration, do the following:    Retrieve it by calling GetLoggingConfiguration    Update its settings as needed   Provide the complete logging configuration specification to this call     You can define one logging destination per web ACL.  You can access information about the traffic that WAF inspects using the following steps:   Create your logging destination. You can use an Amazon CloudWatch Logs log group, an Amazon Simple Storage Service (Amazon S3) bucket, or an Amazon Kinesis Data Firehose.  The name that you give the destination must start with aws-waf-logs-. Depending on the type of destination, you might need to configure additional settings or permissions.  For configuration requirements and pricing information for each destination type, see Logging web ACL traffic in the WAF Developer Guide.   Associate your logging destination to your web ACL using a PutLoggingConfiguration request.   When you successfully enable logging using a PutLoggingConfiguration request, WAF creates an additional role or policy that is required to write logs to the logging destination. For an Amazon CloudWatch Logs log group, WAF creates a resource policy on the log group. For an Amazon S3 bucket, WAF creates a bucket policy. For an Amazon Kinesis Data Firehose, WAF creates a service-linked role. For additional information about web ACL logging, see Logging web ACL traffic information in the WAF Developer Guide.
    */
   putLoggingConfiguration(params: WAFV2.Types.PutLoggingConfigurationRequest, callback?: (err: AWSError, data: WAFV2.Types.PutLoggingConfigurationResponse) => void): Request<WAFV2.Types.PutLoggingConfigurationResponse, AWSError>;
   /**
-   * Enables the specified LoggingConfiguration, to start logging from a web ACL, according to the configuration provided.   You can define one logging destination per web ACL.  You can access information about the traffic that WAF inspects using the following steps:   Create your logging destination. You can use an Amazon CloudWatch Logs log group, an Amazon Simple Storage Service (Amazon S3) bucket, or an Amazon Kinesis Data Firehose.  The name that you give the destination must start with aws-waf-logs-. Depending on the type of destination, you might need to configure additional settings or permissions.  For configuration requirements and pricing information for each destination type, see Logging web ACL traffic in the WAF Developer Guide.   Associate your logging destination to your web ACL using a PutLoggingConfiguration request.   When you successfully enable logging using a PutLoggingConfiguration request, WAF creates an additional role or policy that is required to write logs to the logging destination. For an Amazon CloudWatch Logs log group, WAF creates a resource policy on the log group. For an Amazon S3 bucket, WAF creates a bucket policy. For an Amazon Kinesis Data Firehose, WAF creates a service-linked role. For additional information about web ACL logging, see Logging web ACL traffic information in the WAF Developer Guide.  This operation completely replaces the mutable specifications that you already have for the logging configuration with the ones that you provide to this call. To modify the logging configuration, retrieve it by calling GetLoggingConfiguration, update the settings as needed, and then provide the complete logging configuration specification to this call. 
+   * Enables the specified LoggingConfiguration, to start logging from a web ACL, according to the configuration provided.   This operation completely replaces any mutable specifications that you already have for a logging configuration with the ones that you provide to this call.  To modify an existing logging configuration, do the following:    Retrieve it by calling GetLoggingConfiguration    Update its settings as needed   Provide the complete logging configuration specification to this call     You can define one logging destination per web ACL.  You can access information about the traffic that WAF inspects using the following steps:   Create your logging destination. You can use an Amazon CloudWatch Logs log group, an Amazon Simple Storage Service (Amazon S3) bucket, or an Amazon Kinesis Data Firehose.  The name that you give the destination must start with aws-waf-logs-. Depending on the type of destination, you might need to configure additional settings or permissions.  For configuration requirements and pricing information for each destination type, see Logging web ACL traffic in the WAF Developer Guide.   Associate your logging destination to your web ACL using a PutLoggingConfiguration request.   When you successfully enable logging using a PutLoggingConfiguration request, WAF creates an additional role or policy that is required to write logs to the logging destination. For an Amazon CloudWatch Logs log group, WAF creates a resource policy on the log group. For an Amazon S3 bucket, WAF creates a bucket policy. For an Amazon Kinesis Data Firehose, WAF creates a service-linked role. For additional information about web ACL logging, see Logging web ACL traffic information in the WAF Developer Guide.
    */
   putLoggingConfiguration(callback?: (err: AWSError, data: WAFV2.Types.PutLoggingConfigurationResponse) => void): Request<WAFV2.Types.PutLoggingConfigurationResponse, AWSError>;
   /**
@@ -356,11 +356,11 @@ declare class WAFV2 extends Service {
    */
   untagResource(callback?: (err: AWSError, data: WAFV2.Types.UntagResourceResponse) => void): Request<WAFV2.Types.UntagResourceResponse, AWSError>;
   /**
-   * Updates the specified IPSet.   This operation completely replaces the mutable specifications that you already have for the IP set with the ones that you provide to this call. To modify the IP set, retrieve it by calling GetIPSet, update the settings as needed, and then provide the complete IP set specification to this call.  When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.
+   * Updates the specified IPSet.   This operation completely replaces the mutable specifications that you already have for the IP set with the ones that you provide to this call.  To modify an IP set, do the following:    Retrieve it by calling GetIPSet    Update its settings as needed   Provide the complete IP set specification to this call    When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.
    */
   updateIPSet(params: WAFV2.Types.UpdateIPSetRequest, callback?: (err: AWSError, data: WAFV2.Types.UpdateIPSetResponse) => void): Request<WAFV2.Types.UpdateIPSetResponse, AWSError>;
   /**
-   * Updates the specified IPSet.   This operation completely replaces the mutable specifications that you already have for the IP set with the ones that you provide to this call. To modify the IP set, retrieve it by calling GetIPSet, update the settings as needed, and then provide the complete IP set specification to this call.  When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.
+   * Updates the specified IPSet.   This operation completely replaces the mutable specifications that you already have for the IP set with the ones that you provide to this call.  To modify an IP set, do the following:    Retrieve it by calling GetIPSet    Update its settings as needed   Provide the complete IP set specification to this call    When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.
    */
   updateIPSet(callback?: (err: AWSError, data: WAFV2.Types.UpdateIPSetResponse) => void): Request<WAFV2.Types.UpdateIPSetResponse, AWSError>;
   /**
@@ -372,27 +372,27 @@ declare class WAFV2 extends Service {
    */
   updateManagedRuleSetVersionExpiryDate(callback?: (err: AWSError, data: WAFV2.Types.UpdateManagedRuleSetVersionExpiryDateResponse) => void): Request<WAFV2.Types.UpdateManagedRuleSetVersionExpiryDateResponse, AWSError>;
   /**
-   * Updates the specified RegexPatternSet.  This operation completely replaces the mutable specifications that you already have for the regex pattern set with the ones that you provide to this call. To modify the regex pattern set, retrieve it by calling GetRegexPatternSet, update the settings as needed, and then provide the complete regex pattern set specification to this call.  When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.
+   * Updates the specified RegexPatternSet.  This operation completely replaces the mutable specifications that you already have for the regex pattern set with the ones that you provide to this call.  To modify a regex pattern set, do the following:    Retrieve it by calling GetRegexPatternSet    Update its settings as needed   Provide the complete regex pattern set specification to this call    When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.
    */
   updateRegexPatternSet(params: WAFV2.Types.UpdateRegexPatternSetRequest, callback?: (err: AWSError, data: WAFV2.Types.UpdateRegexPatternSetResponse) => void): Request<WAFV2.Types.UpdateRegexPatternSetResponse, AWSError>;
   /**
-   * Updates the specified RegexPatternSet.  This operation completely replaces the mutable specifications that you already have for the regex pattern set with the ones that you provide to this call. To modify the regex pattern set, retrieve it by calling GetRegexPatternSet, update the settings as needed, and then provide the complete regex pattern set specification to this call.  When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.
+   * Updates the specified RegexPatternSet.  This operation completely replaces the mutable specifications that you already have for the regex pattern set with the ones that you provide to this call.  To modify a regex pattern set, do the following:    Retrieve it by calling GetRegexPatternSet    Update its settings as needed   Provide the complete regex pattern set specification to this call    When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.
    */
   updateRegexPatternSet(callback?: (err: AWSError, data: WAFV2.Types.UpdateRegexPatternSetResponse) => void): Request<WAFV2.Types.UpdateRegexPatternSetResponse, AWSError>;
   /**
-   * Updates the specified RuleGroup.  This operation completely replaces the mutable specifications that you already have for the rule group with the ones that you provide to this call. To modify the rule group, retrieve it by calling GetRuleGroup, update the settings as needed, and then provide the complete rule group specification to this call.  When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.  A rule group defines a collection of rules to inspect and control web requests that you can use in a WebACL. When you create a rule group, you define an immutable capacity limit. If you update a rule group, you must stay within the capacity. This allows others to reuse the rule group with confidence in its capacity requirements. 
+   * Updates the specified RuleGroup.  This operation completely replaces the mutable specifications that you already have for the rule group with the ones that you provide to this call.  To modify a rule group, do the following:    Retrieve it by calling GetRuleGroup    Update its settings as needed   Provide the complete rule group specification to this call    When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.  A rule group defines a collection of rules to inspect and control web requests that you can use in a WebACL. When you create a rule group, you define an immutable capacity limit. If you update a rule group, you must stay within the capacity. This allows others to reuse the rule group with confidence in its capacity requirements. 
    */
   updateRuleGroup(params: WAFV2.Types.UpdateRuleGroupRequest, callback?: (err: AWSError, data: WAFV2.Types.UpdateRuleGroupResponse) => void): Request<WAFV2.Types.UpdateRuleGroupResponse, AWSError>;
   /**
-   * Updates the specified RuleGroup.  This operation completely replaces the mutable specifications that you already have for the rule group with the ones that you provide to this call. To modify the rule group, retrieve it by calling GetRuleGroup, update the settings as needed, and then provide the complete rule group specification to this call.  When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.  A rule group defines a collection of rules to inspect and control web requests that you can use in a WebACL. When you create a rule group, you define an immutable capacity limit. If you update a rule group, you must stay within the capacity. This allows others to reuse the rule group with confidence in its capacity requirements. 
+   * Updates the specified RuleGroup.  This operation completely replaces the mutable specifications that you already have for the rule group with the ones that you provide to this call.  To modify a rule group, do the following:    Retrieve it by calling GetRuleGroup    Update its settings as needed   Provide the complete rule group specification to this call    When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.  A rule group defines a collection of rules to inspect and control web requests that you can use in a WebACL. When you create a rule group, you define an immutable capacity limit. If you update a rule group, you must stay within the capacity. This allows others to reuse the rule group with confidence in its capacity requirements. 
    */
   updateRuleGroup(callback?: (err: AWSError, data: WAFV2.Types.UpdateRuleGroupResponse) => void): Request<WAFV2.Types.UpdateRuleGroupResponse, AWSError>;
   /**
-   * Updates the specified WebACL. While updating a web ACL, WAF provides continuous coverage to the resources that you have associated with the web ACL.  When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.  This operation completely replaces the mutable specifications that you already have for the web ACL with the ones that you provide to this call. To modify the web ACL, retrieve it by calling GetWebACL, update the settings as needed, and then provide the complete web ACL specification to this call.   A web ACL defines a collection of rules to use to inspect and control web requests. Each rule has an action defined (allow, block, or count) for requests that match the statement of the rule. In the web ACL, you assign a default action to take (allow, block) for any request that does not match any of the rules. The rules in a web ACL can be a combination of the types Rule, RuleGroup, and managed rule group. You can associate a web ACL with one or more Amazon Web Services resources to protect. The resources can be an Amazon CloudFront distribution, an Amazon API Gateway REST API, an Application Load Balancer, an AppSync GraphQL API, or an Amazon Cognito user pool. 
+   * Updates the specified WebACL. While updating a web ACL, WAF provides continuous coverage to the resources that you have associated with the web ACL.   This operation completely replaces the mutable specifications that you already have for the web ACL with the ones that you provide to this call.  To modify a web ACL, do the following:    Retrieve it by calling GetWebACL    Update its settings as needed   Provide the complete web ACL specification to this call    When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.  A web ACL defines a collection of rules to use to inspect and control web requests. Each rule has an action defined (allow, block, or count) for requests that match the statement of the rule. In the web ACL, you assign a default action to take (allow, block) for any request that does not match any of the rules. The rules in a web ACL can be a combination of the types Rule, RuleGroup, and managed rule group. You can associate a web ACL with one or more Amazon Web Services resources to protect. The resources can be an Amazon CloudFront distribution, an Amazon API Gateway REST API, an Application Load Balancer, an AppSync GraphQL API, or an Amazon Cognito user pool. 
    */
   updateWebACL(params: WAFV2.Types.UpdateWebACLRequest, callback?: (err: AWSError, data: WAFV2.Types.UpdateWebACLResponse) => void): Request<WAFV2.Types.UpdateWebACLResponse, AWSError>;
   /**
-   * Updates the specified WebACL. While updating a web ACL, WAF provides continuous coverage to the resources that you have associated with the web ACL.  When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.  This operation completely replaces the mutable specifications that you already have for the web ACL with the ones that you provide to this call. To modify the web ACL, retrieve it by calling GetWebACL, update the settings as needed, and then provide the complete web ACL specification to this call.   A web ACL defines a collection of rules to use to inspect and control web requests. Each rule has an action defined (allow, block, or count) for requests that match the statement of the rule. In the web ACL, you assign a default action to take (allow, block) for any request that does not match any of the rules. The rules in a web ACL can be a combination of the types Rule, RuleGroup, and managed rule group. You can associate a web ACL with one or more Amazon Web Services resources to protect. The resources can be an Amazon CloudFront distribution, an Amazon API Gateway REST API, an Application Load Balancer, an AppSync GraphQL API, or an Amazon Cognito user pool. 
+   * Updates the specified WebACL. While updating a web ACL, WAF provides continuous coverage to the resources that you have associated with the web ACL.   This operation completely replaces the mutable specifications that you already have for the web ACL with the ones that you provide to this call.  To modify a web ACL, do the following:    Retrieve it by calling GetWebACL    Update its settings as needed   Provide the complete web ACL specification to this call    When you make changes to web ACLs or web ACL components, like rules and rule groups, WAF propagates the changes everywhere that the web ACL and its components are stored and used. Your changes are applied within seconds, but there might be a brief period of inconsistency when the changes have arrived in some places and not in others. So, for example, if you change a rule action setting, the action might be the old action in one area and the new action in another area. Or if you add an IP address to an IP set used in a blocking rule, the new address might briefly be blocked in one area while still allowed in another. This temporary inconsistency can occur when you first associate a web ACL with an Amazon Web Services resource and when you change a web ACL that is already associated with a resource. Generally, any inconsistencies of this type last only a few seconds.  A web ACL defines a collection of rules to use to inspect and control web requests. Each rule has an action defined (allow, block, or count) for requests that match the statement of the rule. In the web ACL, you assign a default action to take (allow, block) for any request that does not match any of the rules. The rules in a web ACL can be a combination of the types Rule, RuleGroup, and managed rule group. You can associate a web ACL with one or more Amazon Web Services resources to protect. The resources can be an Amazon CloudFront distribution, an Amazon API Gateway REST API, an Application Load Balancer, an AppSync GraphQL API, or an Amazon Cognito user pool. 
    */
   updateWebACL(callback?: (err: AWSError, data: WAFV2.Types.UpdateWebACLResponse) => void): Request<WAFV2.Types.UpdateWebACLResponse, AWSError>;
 }
@@ -1288,7 +1288,7 @@ declare namespace WAFV2 {
      */
     WebAclArn: ResourceArn;
     /**
-     * The metric name assigned to the Rule or RuleGroup for which you want a sample of requests.
+     * The metric name assigned to the Rule or RuleGroup dimension for which you want a sample of requests.
      */
     RuleMetricName: MetricName;
     /**
@@ -2934,7 +2934,7 @@ declare namespace WAFV2 {
      */
     CloudWatchMetricsEnabled: Boolean;
     /**
-     * A name of the Amazon CloudWatch metric. The name can contain only the characters: A-Z, a-z, 0-9, - (hyphen), and _ (underscore). The name can be from one to 128 characters long. It can't contain whitespace or metric names reserved for WAF, for example All and Default_Action. 
+     * A name of the Amazon CloudWatch metric dimension. The name can contain only the characters: A-Z, a-z, 0-9, - (hyphen), and _ (underscore). The name can be from one to 128 characters long. It can't contain whitespace or metric names that are reserved for WAF, for example All and Default_Action. 
      */
     MetricName: MetricName;
   }

package/node_modules/aws-sdk/dist/aws-sdk-core-react-native.js

@@ -83,7 +83,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	  /**
 	   * @constant
 	   */
-	  VERSION: '2.1296.0',
+	  VERSION: '2.1298.0',
 
 	  /**
 	   * @api private