@pulumi/aws-native 0.81.0 → 0.82.0

package/types/input.d.ts

@@ -1187,16 +1187,24 @@ export declare namespace apigateway {
         key: pulumi.Input<string>;
         value: pulumi.Input<string>;
     }
+    /**
+     * The ``AccessLogSetting`` property type specifies settings for logging access in this stage.
+     *   ``AccessLogSetting`` is a property of the [StageDescription](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-deployment-stagedescription.html) property type.
+     */
     interface DeploymentAccessLogSettingArgs {
         /**
-         * The Amazon Resource Name (ARN) of the CloudWatch Logs log group or Kinesis Data Firehose delivery stream to receive access logs. If you specify a Kinesis Data Firehose delivery stream, the stream name must begin with amazon-apigateway-.
+         * The Amazon Resource Name (ARN) of the CloudWatch Logs log group or Kinesis Data Firehose delivery stream to receive access logs. If you specify a Kinesis Data Firehose delivery stream, the stream name must begin with ``amazon-apigateway-``.
          */
         destinationArn?: pulumi.Input<string>;
         /**
-         * A single line format of the access logs of data, as specified by selected $context variables. The format must include at least $context.requestId.
+         * A single line format of the access logs of data, as specified by selected $context variables. The format must include at least ``$context.requestId``.
          */
         format?: pulumi.Input<string>;
     }
+    /**
+     * The ``CanarySetting`` property type specifies settings for the canary deployment in this stage.
+     *  ``CanarySetting`` is a property of the [StageDescription](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-deployment-stagedescription.html) property type.
+     */
     interface DeploymentCanarySettingArgs {
         /**
          * The percent (0-100) of traffic diverted to a canary deployment.
@@ -1207,39 +1215,46 @@ export declare namespace apigateway {
          */
         stageVariableOverrides?: any;
         /**
-         * Whether the canary deployment uses the stage cache or not.
+         * A Boolean flag to indicate whether the canary deployment uses the stage cache or not.
          */
         useStageCache?: pulumi.Input<boolean>;
     }
+    /**
+     * The ``DeploymentCanarySettings`` property type specifies settings for the canary deployment.
+     */
     interface DeploymentCanarySettingsArgs {
         /**
-         * The percentage (0-100) of traffic diverted to a canary deployment.
+         * The percentage (0.0-100.0) of traffic routed to the canary deployment.
          */
         percentTraffic?: pulumi.Input<number>;
         /**
-         * Stage variables overridden for a canary release deployment, including new stage variables introduced in the canary. These stage variables are represented as a string-to-string map between stage variable names and their values. Duplicates are not allowed.
+         * A stage variable overrides used for the canary release deployment. They can override existing stage variables or add new stage variables for the canary release deployment. These stage variables are represented as a string-to-string map between stage variable names and their values.
          */
         stageVariableOverrides?: any;
         /**
-         * Whether the canary deployment uses the stage cache.
+         * A Boolean flag to indicate whether the canary release deployment uses the stage cache or not.
          */
         useStageCache?: pulumi.Input<boolean>;
     }
+    /**
+     * The ``MethodSetting`` property type configures settings for all methods in a stage.
+     *  The ``MethodSettings`` property of the [Amazon API Gateway Deployment StageDescription](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-deployment-stagedescription.html) property type contains a list of ``MethodSetting`` property types.
+     */
     interface DeploymentMethodSettingArgs {
         /**
-         * Indicates whether the cached responses are encrypted
+         * Specifies whether the cached responses are encrypted.
          */
         cacheDataEncrypted?: pulumi.Input<boolean>;
         /**
-         * The time-to-live (TTL) period, in seconds, that specifies how long API Gateway caches responses.
+         * Specifies the time to live (TTL), in seconds, for cached responses. The higher the TTL, the longer the response will be cached.
          */
         cacheTtlInSeconds?: pulumi.Input<number>;
         /**
-         * Indicates whether responses are cached and returned for requests. You must enable a cache cluster on the stage to cache responses.
+         * Specifies whether responses should be cached and returned for requests. A cache cluster must be enabled on the stage for responses to be cached.
          */
         cachingEnabled?: pulumi.Input<boolean>;
         /**
-         * Indicates whether data trace logging is enabled for methods in the stage. API Gateway pushes these logs to Amazon CloudWatch Logs.
+         * Specifies whether data trace logging is enabled for this method, which affects the log entries pushed to Amazon CloudWatch Logs. This can be useful to troubleshoot APIs, but can result in logging sensitive data. We recommend that you don't enable this option for production APIs.
          */
         dataTraceEnabled?: pulumi.Input<boolean>;
         /**
@@ -1247,41 +1262,44 @@ export declare namespace apigateway {
          */
         httpMethod?: pulumi.Input<string>;
         /**
-         * The logging level for this method. For valid values, see the loggingLevel property of the Stage resource in the Amazon API Gateway API Reference.
+         * Specifies the logging level for this method, which affects the log entries pushed to Amazon CloudWatch Logs. Valid values are ``OFF``, ``ERROR``, and ``INFO``. Choose ``ERROR`` to write only error-level entries to CloudWatch Logs, or choose ``INFO`` to include all ``ERROR`` events as well as extra informational events.
          */
         loggingLevel?: pulumi.Input<string>;
         /**
-         * Indicates whether Amazon CloudWatch metrics are enabled for methods in the stage.
+         * Specifies whether Amazon CloudWatch metrics are enabled for this method.
          */
         metricsEnabled?: pulumi.Input<boolean>;
         /**
-         * The resource path for this method. Forward slashes (/) are encoded as ~1 and the initial slash must include a forward slash.
+         * The resource path for this method. Forward slashes (``/``) are encoded as ``~1`` and the initial slash must include a forward slash. For example, the path value ``/resource/subresource`` must be encoded as ``/~1resource~1subresource``. To specify the root path, use only a slash (``/``).
          */
         resourcePath?: pulumi.Input<string>;
         /**
-         * The number of burst requests per second that API Gateway permits across all APIs, stages, and methods in your AWS account.
+         * Specifies the throttling burst limit.
          */
         throttlingBurstLimit?: pulumi.Input<number>;
         /**
-         * The number of steady-state requests per second that API Gateway permits across all APIs, stages, and methods in your AWS account.
+         * Specifies the throttling rate limit.
          */
         throttlingRateLimit?: pulumi.Input<number>;
     }
+    /**
+     * ``StageDescription`` is a property of the [AWS::ApiGateway::Deployment](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-deployment.html) resource that configures a deployment stage.
+     */
     interface DeploymentStageDescriptionArgs {
         /**
          * Specifies settings for logging access in this stage.
          */
         accessLogSetting?: pulumi.Input<inputs.apigateway.DeploymentAccessLogSettingArgs>;
         /**
-         * Indicates whether cache clustering is enabled for the stage.
+         * Specifies whether a cache cluster is enabled for the stage.
          */
         cacheClusterEnabled?: pulumi.Input<boolean>;
         /**
-         * The size of the stage's cache cluster.
+         * The size of the stage's cache cluster. For more information, see [cacheClusterSize](https://docs.aws.amazon.com/apigateway/latest/api/API_CreateStage.html#apigw-CreateStage-request-cacheClusterSize) in the *API Gateway API Reference*.
          */
         cacheClusterSize?: pulumi.Input<string>;
         /**
-         * The time-to-live (TTL) period, in seconds, that specifies how long API Gateway caches responses.
+         * Indicates whether the cached responses are encrypted.
          */
         cacheDataEncrypted?: pulumi.Input<boolean>;
         /**
@@ -1289,7 +1307,7 @@ export declare namespace apigateway {
          */
         cacheTtlInSeconds?: pulumi.Input<number>;
         /**
-         * Indicates whether responses are cached and returned for requests. You must enable a cache cluster on the stage to cache responses.
+         * Indicates whether responses are cached and returned for requests. You must enable a cache cluster on the stage to cache responses. For more information, see [Enable API Gateway Caching in a Stage to Enhance API Performance](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-caching.html) in the *API Gateway Developer Guide*.
          */
         cachingEnabled?: pulumi.Input<boolean>;
         /**
@@ -1313,7 +1331,7 @@ export declare namespace apigateway {
          */
         documentationVersion?: pulumi.Input<string>;
         /**
-         * The logging level for this method. For valid values, see the loggingLevel property of the Stage resource in the Amazon API Gateway API Reference.
+         * The logging level for this method. For valid values, see the ``loggingLevel`` property of the [MethodSetting](https://docs.aws.amazon.com/apigateway/latest/api/API_MethodSetting.html) resource in the *Amazon API Gateway API Reference*.
          */
         loggingLevel?: pulumi.Input<string>;
         /**
@@ -1329,19 +1347,20 @@ export declare namespace apigateway {
          */
         tags?: pulumi.Input<pulumi.Input<inputs.apigateway.DeploymentTagArgs>[]>;
         /**
-         * The number of burst requests per second that API Gateway permits across all APIs, stages, and methods in your AWS account.
+         * The target request burst rate limit. This allows more requests through for a period of time than the target rate limit. For more information, see [Manage API Request Throttling](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-request-throttling.html) in the *API Gateway Developer Guide*.
          */
         throttlingBurstLimit?: pulumi.Input<number>;
         /**
-         * The number of steady-state requests per second that API Gateway permits across all APIs, stages, and methods in your AWS account.
+         * The target request steady-state rate limit. For more information, see [Manage API Request Throttling](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-request-throttling.html) in the *API Gateway Developer Guide*.
          */
         throttlingRateLimit?: pulumi.Input<number>;
         /**
          * Specifies whether active tracing with X-ray is enabled for this stage.
+         *  For more information, see [Trace API Gateway API Execution with X-Ray](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-xray.html) in the *API Gateway Developer Guide*.
          */
         tracingEnabled?: pulumi.Input<boolean>;
         /**
-         * A map that defines the stage variables. Variable names must consist of alphanumeric characters, and the values must match the following regular expression: [A-Za-z0-9-._~:/?#&=,]+.
+         * A map that defines the stage variables. Variable names must consist of alphanumeric characters, and the values must match the following regular expression: ``[A-Za-z0-9-._~:/?#&=,]+``.
          */
         variables?: any;
     }
@@ -1355,25 +1374,29 @@ export declare namespace apigateway {
          */
         value: pulumi.Input<string>;
     }
+    /**
+     * The ``Location`` property specifies the location of the Amazon API Gateway API entity that the documentation applies to. ``Location`` is a property of the [AWS::ApiGateway::DocumentationPart](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-documentationpart.html) resource.
+     *  For more information about each property, including constraints and valid values, see [DocumentationPart](https://docs.aws.amazon.com/apigateway/latest/api/API_DocumentationPartLocation.html) in the *Amazon API Gateway REST API Reference*.
+     */
     interface DocumentationPartLocationArgs {
         /**
-         * The HTTP verb of a method.
+         * The HTTP verb of a method. It is a valid field for the API entity types of ``METHOD``, ``PATH_PARAMETER``, ``QUERY_PARAMETER``, ``REQUEST_HEADER``, ``REQUEST_BODY``, ``RESPONSE``, ``RESPONSE_HEADER``, and ``RESPONSE_BODY``. The default value is ``*`` for any method. When an applicable child entity inherits the content of an entity of the same type with more general specifications of the other ``location`` attributes, the child entity's ``method`` attribute must match that of the parent entity exactly.
          */
         method?: pulumi.Input<string>;
         /**
-         * The name of the targeted API entity.
+         * The name of the targeted API entity. It is a valid and required field for the API entity types of ``AUTHORIZER``, ``MODEL``, ``PATH_PARAMETER``, ``QUERY_PARAMETER``, ``REQUEST_HEADER``, ``REQUEST_BODY`` and ``RESPONSE_HEADER``. It is an invalid field for any other entity type.
          */
         name?: pulumi.Input<string>;
         /**
-         * The URL path of the target.
+         * The URL path of the target. It is a valid field for the API entity types of ``RESOURCE``, ``METHOD``, ``PATH_PARAMETER``, ``QUERY_PARAMETER``, ``REQUEST_HEADER``, ``REQUEST_BODY``, ``RESPONSE``, ``RESPONSE_HEADER``, and ``RESPONSE_BODY``. The default value is ``/`` for the root resource. When an applicable child entity inherits the content of another entity of the same type with more general specifications of the other ``location`` attributes, the child entity's ``path`` attribute must match that of the parent entity as a prefix.
          */
         path?: pulumi.Input<string>;
         /**
-         * The HTTP status code of a response.
+         * The HTTP status code of a response. It is a valid field for the API entity types of ``RESPONSE``, ``RESPONSE_HEADER``, and ``RESPONSE_BODY``. The default value is ``*`` for any status code. When an applicable child entity inherits the content of an entity of the same type with more general specifications of the other ``location`` attributes, the child entity's ``statusCode`` attribute must match that of the parent entity exactly.
          */
         statusCode?: pulumi.Input<string>;
         /**
-         * The type of API entity that the documentation content applies to.
+         * The type of API entity to which the documentation content applies. Valid values are ``API``, ``AUTHORIZER``, ``MODEL``, ``RESOURCE``, ``METHOD``, ``PATH_PARAMETER``, ``QUERY_PARAMETER``, ``REQUEST_HEADER``, ``REQUEST_BODY``, ``RESPONSE``, ``RESPONSE_HEADER``, and ``RESPONSE_BODY``. Content inheritance does not apply to any entity of the ``API``, ``AUTHORIZER``, ``METHOD``, ``MODEL``, ``REQUEST_BODY``, or ``RESOURCE`` type.
          */
         type?: pulumi.Input<enums.apigateway.DocumentationPartLocationType>;
     }
@@ -1388,108 +1411,147 @@ export declare namespace apigateway {
         key?: pulumi.Input<string>;
         value?: pulumi.Input<string>;
     }
+    /**
+     * ``Integration`` is a property of the [AWS::ApiGateway::Method](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-method.html) resource that specifies information about the target backend that a method calls.
+     */
     interface MethodIntegrationArgs {
         /**
-         * A list of request parameters whose values API Gateway caches.
+         * A list of request parameters whose values API Gateway caches. To be valid values for ``cacheKeyParameters``, these parameters must also be specified for Method ``requestParameters``.
          */
         cacheKeyParameters?: pulumi.Input<pulumi.Input<string>[]>;
         /**
-         * An API-specific tag group of related cached parameters.
+         * Specifies a group of related cached parameters. By default, API Gateway uses the resource ID as the ``cacheNamespace``. You can specify the same ``cacheNamespace`` across resources to return the same cached data for requests to different resources.
          */
         cacheNamespace?: pulumi.Input<string>;
         /**
-         * The ID of the VpcLink used for the integration when connectionType=VPC_LINK, otherwise undefined.
+         * The ID of the VpcLink used for the integration when ``connectionType=VPC_LINK`` and undefined, otherwise.
          */
         connectionId?: pulumi.Input<string>;
         /**
-         * The type of the network connection to the integration endpoint.
+         * The type of the network connection to the integration endpoint. The valid value is ``INTERNET`` for connections through the public routable internet or ``VPC_LINK`` for private connections between API Gateway and a network load balancer in a VPC. The default value is ``INTERNET``.
          */
         connectionType?: pulumi.Input<enums.apigateway.MethodIntegrationConnectionType>;
         /**
-         * Specifies how to handle request payload content type conversions.
+         * Specifies how to handle request payload content type conversions. Supported values are ``CONVERT_TO_BINARY`` and ``CONVERT_TO_TEXT``, with the following behaviors:
+         *  If this property is not defined, the request payload will be passed through from the method request to integration request without modification, provided that the ``passthroughBehavior`` is configured to support payload pass-through.
          */
         contentHandling?: pulumi.Input<enums.apigateway.MethodIntegrationContentHandling>;
         /**
-         * The credentials that are required for the integration.
+         * Specifies the credentials required for the integration, if any. For AWS integrations, three options are available. To specify an IAM Role for API Gateway to assume, use the role's Amazon Resource Name (ARN). To require that the caller's identity be passed through from the request, specify the string ``arn:aws:iam::\*:user/\*``. To use resource-based permissions on supported AWS services, specify null.
          */
         credentials?: pulumi.Input<string>;
         /**
-         * The integration's HTTP method type.
+         * Specifies the integration's HTTP method type. For the Type property, if you specify ``MOCK``, this property is optional. For Lambda integrations, you must set the integration method to ``POST``. For all other types, you must specify this property.
          */
         integrationHttpMethod?: pulumi.Input<string>;
         /**
-         * The response that API Gateway provides after a method's backend completes processing a request.
+         * Specifies the integration's responses.
          */
         integrationResponses?: pulumi.Input<pulumi.Input<inputs.apigateway.MethodIntegrationResponseArgs>[]>;
         /**
-         * Indicates when API Gateway passes requests to the targeted backend.
+         * Specifies how the method request body of an unmapped content type will be passed through the integration request to the back end without transformation. A content type is unmapped if no mapping template is defined in the integration or the content type does not match any of the mapped content types, as specified in ``requestTemplates``. The valid value is one of the following: ``WHEN_NO_MATCH``: passes the method request body through the integration request to the back end without transformation when the method request content type does not match any content type associated with the mapping templates defined in the integration request. ``WHEN_NO_TEMPLATES``: passes the method request body through the integration request to the back end without transformation when no mapping template is defined in the integration request. If a template is defined when this option is selected, the method request of an unmapped content-type will be rejected with an HTTP 415 Unsupported Media Type response. ``NEVER``: rejects the method request with an HTTP 415 Unsupported Media Type response when either the method request content type does not match any content type associated with the mapping templates defined in the integration request or no mapping template is defined in the integration request.
          */
         passthroughBehavior?: pulumi.Input<enums.apigateway.MethodIntegrationPassthroughBehavior>;
         /**
-         * The request parameters that API Gateway sends with the backend request.
+         * A key-value map specifying request parameters that are passed from the method request to the back end. The key is an integration request parameter name and the associated value is a method request parameter value or static value that must be enclosed within single quotes and pre-encoded as required by the back end. The method request parameter value must match the pattern of ``method.request.{location}.{name}``, where ``location`` is ``querystring``, ``path``, or ``header`` and ``name`` must be a valid and unique method request parameter name.
          */
         requestParameters?: any;
         /**
-         * A map of Apache Velocity templates that are applied on the request payload.
+         * Represents a map of Velocity templates that are applied on the request payload based on the value of the Content-Type header sent by the client. The content type value is the key in this map, and the template (as a String) is the value.
          */
         requestTemplates?: any;
         /**
-         * Custom timeout between 50 and 29,000 milliseconds.
+         * Custom timeout between 50 and 29,000 milliseconds. The default value is 29,000 milliseconds or 29 seconds.
          */
         timeoutInMillis?: pulumi.Input<number>;
         /**
-         * The type of backend that your method is running.
+         * Specifies an API method integration type. The valid value is one of the following:
+         *  For the HTTP and HTTP proxy integrations, each integration can specify a protocol (``http/https``), port and path. Standard 80 and 443 ports are supported as well as custom ports above 1024. An HTTP or HTTP proxy integration with a ``connectionType`` of ``VPC_LINK`` is referred to as a private integration and uses a VpcLink to connect API Gateway to a network load balancer of a VPC.
          */
         type: pulumi.Input<enums.apigateway.MethodIntegrationType>;
         /**
-         * The Uniform Resource Identifier (URI) for the integration.
+         * Specifies Uniform Resource Identifier (URI) of the integration endpoint.
+         *  For ``HTTP`` or ``HTTP_PROXY`` integrations, the URI must be a fully formed, encoded HTTP(S) URL according to the RFC-3986 specification for standard integrations. If ``connectionType`` is ``VPC_LINK`` specify the Network Load Balancer DNS name. For ``AWS`` or ``AWS_PROXY`` integrations, the URI is of the form ``arn:aws:apigateway:{region}:{subdomain.service|service}:path|action/{service_api}``. Here, {Region} is the API Gateway region (e.g., us-east-1); {service} is the name of the integrated AWS service (e.g., s3); and {subdomain} is a designated subdomain supported by certain AWS service for fast host-name lookup. action can be used for an AWS service action-based API, using an Action={name}&{p1}={v1}&p2={v2}... query string. The ensuing {service_api} refers to a supported action {name} plus any required input parameters. Alternatively, path can be used for an AWS service path-based API. The ensuing service_api refers to the path to an AWS service resource, including the region of the integrated AWS service, if applicable. For example, for integration with the S3 API of GetObject, the uri can be either ``arn:aws:apigateway:us-west-2:s3:action/GetObject&Bucket={bucket}&Key={key}`` or ``arn:aws:apigateway:us-west-2:s3:path/{bucket}/{key}``
          */
         uri?: pulumi.Input<string>;
     }
+    /**
+     * ``IntegrationResponse`` is a property of the [Amazon API Gateway Method Integration](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apitgateway-method-integration.html) property type that specifies the response that API Gateway sends after a method's backend finishes processing a request.
+     */
     interface MethodIntegrationResponseArgs {
         /**
-         * Specifies how to handle request payload content type conversions.
+         * Specifies how to handle response payload content type conversions. Supported values are ``CONVERT_TO_BINARY`` and ``CONVERT_TO_TEXT``, with the following behaviors:
+         *  If this property is not defined, the response payload will be passed through from the integration response to the method response without modification.
          */
         contentHandling?: pulumi.Input<enums.apigateway.MethodIntegrationResponseContentHandling>;
         /**
-         * The response parameters from the backend response that API Gateway sends to the method response.
+         * A key-value map specifying response parameters that are passed to the method response from the back end. The key is a method response header parameter name and the mapped value is an integration response header value, a static value enclosed within a pair of single quotes, or a JSON expression from the integration response body. The mapping key must match the pattern of ``method.response.header.{name}``, where ``name`` is a valid and unique header name. The mapped non-static value must match the pattern of ``integration.response.header.{name}`` or ``integration.response.body.{JSON-expression}``, where ``name`` is a valid and unique response header name and ``JSON-expression`` is a valid JSON expression without the ``$`` prefix.
          */
         responseParameters?: any;
         /**
-         * The templates that are used to transform the integration response body. Specify templates as key-value pairs (string-to-string mappings), with a content type as the key and a template as the value.
+         * Specifies the templates used to transform the integration response body. Response templates are represented as a key/value map, with a content-type as the key and a template as the value.
          */
         responseTemplates?: any;
         /**
-         * A regular expression that specifies which error strings or status codes from the backend map to the integration response.
+         * Specifies the regular expression (regex) pattern used to choose an integration response based on the response from the back end. For example, if the success response returns nothing and the error response returns some string, you could use the ``.+`` regex to match error response. However, make sure that the error response does not contain any newline (``\n``) character in such cases. If the back end is an LAMlong function, the LAMlong function error header is matched. For all other HTTP and AWS back ends, the HTTP status code is matched.
          */
         selectionPattern?: pulumi.Input<string>;
         /**
-         * The status code that API Gateway uses to map the integration response to a MethodResponse status code.
+         * Specifies the status code that is used to map the integration response to an existing MethodResponse.
          */
         statusCode: pulumi.Input<string>;
     }
+    /**
+     * Represents a method response of a given HTTP status code returned to the client. The method response is passed from the back end through the associated integration response that can be transformed using a mapping template.
+     */
     interface MethodResponseArgs {
         /**
-         * The resources used for the response's content type. Specify response models as key-value pairs (string-to-string maps), with a content type as the key and a Model resource name as the value.
+         * Specifies the Model resources used for the response's content-type. Response models are represented as a key/value map, with a content-type as the key and a Model name as the value.
          */
         responseModels?: any;
         /**
-         * Response parameters that API Gateway sends to the client that called a method. Specify response parameters as key-value pairs (string-to-Boolean maps), with a destination as the key and a Boolean as the value.
+         * A key-value map specifying required or optional response parameters that API Gateway can send back to the caller. A key defines a method response header and the value specifies whether the associated method response header is required or not. The expression of the key must match the pattern ``method.response.header.{name}``, where ``name`` is a valid and unique header name. API Gateway passes certain integration response data to the method response headers specified here according to the mapping you prescribe in the API's IntegrationResponse. The integration response data that can be mapped include an integration response header expressed in ``integration.response.header.{name}``, a static value enclosed within a pair of single quotes (e.g., ``'application/json'``), or a JSON expression from the back-end response payload in the form of ``integration.response.body.{JSON-expression}``, where ``JSON-expression`` is a valid JSON expression without the ``$`` prefix.)
          */
         responseParameters?: any;
         /**
-         * The method response's status code, which you map to an IntegrationResponse.
+         * The method response's status code.
          */
         statusCode: pulumi.Input<string>;
     }
+    /**
+     * The ``EndpointConfiguration`` property type specifies the endpoint types of a REST API.
+     *  ``EndpointConfiguration`` is a property of the [AWS::ApiGateway::RestApi](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-restapi.html) resource.
+     */
     interface RestApiEndpointConfigurationArgs {
+        /**
+         * A list of endpoint types of an API (RestApi) or its custom domain name (DomainName). For an edge-optimized API and its custom domain name, the endpoint type is ``"EDGE"``. For a regional API and its custom domain name, the endpoint type is ``REGIONAL``. For a private API, the endpoint type is ``PRIVATE``.
+         */
         types?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * A list of VpcEndpointIds of an API (RestApi) against which to create Route53 ALIASes. It is only supported for ``PRIVATE`` endpoint type.
+         */
         vpcEndpointIds?: pulumi.Input<pulumi.Input<string>[]>;
     }
+    /**
+     * ``S3Location`` is a property of the [AWS::ApiGateway::RestApi](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-restapi.html) resource that specifies the Amazon S3 location of a OpenAPI (formerly Swagger) file that defines a set of RESTful APIs in JSON or YAML.
+     *  On January 1, 2016, the Swagger Specification was donated to the [OpenAPI initiative](https://docs.aws.amazon.com/https://www.openapis.org/), becoming the foundation of the OpenAPI Specification.
+     */
     interface RestApiS3LocationArgs {
+        /**
+         * The name of the S3 bucket where the OpenAPI file is stored.
+         */
         bucket?: pulumi.Input<string>;
+        /**
+         * The Amazon S3 ETag (a file checksum) of the OpenAPI file. If you don't specify a value, API Gateway skips ETag validation of your OpenAPI file.
+         */
         eTag?: pulumi.Input<string>;
+        /**
+         * The file name of the OpenAPI file (Amazon S3 object name).
+         */
         key?: pulumi.Input<string>;
+        /**
+         * For versioning-enabled buckets, a specific version of the OpenAPI file.
+         */
         version?: pulumi.Input<string>;
     }
     interface RestApiTagArgs {
@@ -1497,28 +1559,29 @@ export declare namespace apigateway {
         value: pulumi.Input<string>;
     }
     /**
-     * Specifies settings for logging access in this stage.
+     * The ``AccessLogSetting`` property type specifies settings for logging access in this stage.
+     *   ``AccessLogSetting`` is a property of the [AWS::ApiGateway::Stage](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-stage.html) resource.
      */
     interface StageAccessLogSettingArgs {
         /**
-         * The Amazon Resource Name (ARN) of the CloudWatch Logs log group or Kinesis Data Firehose delivery stream to receive access logs. If you specify a Kinesis Data Firehose delivery stream, the stream name must begin with amazon-apigateway-. This parameter is required to enable access logging.
+         * The Amazon Resource Name (ARN) of the CloudWatch Logs log group or Kinesis Data Firehose delivery stream to receive access logs. If you specify a Kinesis Data Firehose delivery stream, the stream name must begin with ``amazon-apigateway-``. This parameter is required to enable access logging.
          */
         destinationArn?: pulumi.Input<string>;
         /**
-         * A single line format of the access logs of data, as specified by selected $context variables (https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html#context-variable-reference). The format must include at least $context.requestId. This parameter is required to enable access logging.
+         * A single line format of the access logs of data, as specified by selected [$context variables](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html#context-variable-reference). The format must include at least ``$context.requestId``. This parameter is required to enable access logging.
          */
         format?: pulumi.Input<string>;
     }
     /**
-     * Specifies settings for the canary deployment in this stage.
+     * Configuration settings of a canary deployment.
      */
     interface StageCanarySettingArgs {
         /**
-         * The identifier of the deployment that the stage points to.
+         * The ID of the canary deployment.
          */
         deploymentId?: pulumi.Input<string>;
         /**
-         * The percentage (0-100) of traffic diverted to a canary deployment.
+         * The percent (0-100) of traffic diverted to a canary deployment.
          */
         percentTraffic?: pulumi.Input<number>;
         /**
@@ -1526,52 +1589,53 @@ export declare namespace apigateway {
          */
         stageVariableOverrides?: any;
         /**
-         * Whether the canary deployment uses the stage cache or not.
+         * A Boolean flag to indicate whether the canary deployment uses the stage cache or not.
          */
         useStageCache?: pulumi.Input<boolean>;
     }
     /**
-     * Configures settings for all methods in a stage.
+     * The ``MethodSetting`` property type configures settings for all methods in a stage.
+     *  The ``MethodSettings`` property of the ``AWS::ApiGateway::Stage`` resource contains a list of ``MethodSetting`` property types.
      */
     interface StageMethodSettingArgs {
         /**
-         * Indicates whether the cached responses are encrypted.
+         * Specifies whether the cached responses are encrypted.
          */
         cacheDataEncrypted?: pulumi.Input<boolean>;
         /**
-         * The time-to-live (TTL) period, in seconds, that specifies how long API Gateway caches responses.
+         * Specifies the time to live (TTL), in seconds, for cached responses. The higher the TTL, the longer the response will be cached.
          */
         cacheTtlInSeconds?: pulumi.Input<number>;
         /**
-         * Indicates whether responses are cached and returned for requests. You must enable a cache cluster on the stage to cache responses.
+         * Specifies whether responses should be cached and returned for requests. A cache cluster must be enabled on the stage for responses to be cached.
          */
         cachingEnabled?: pulumi.Input<boolean>;
         /**
-         * Indicates whether data trace logging is enabled for methods in the stage. API Gateway pushes these logs to Amazon CloudWatch Logs.
+         * Specifies whether data trace logging is enabled for this method, which affects the log entries pushed to Amazon CloudWatch Logs. This can be useful to troubleshoot APIs, but can result in logging sensitive data. We recommend that you don't enable this option for production APIs.
          */
         dataTraceEnabled?: pulumi.Input<boolean>;
         /**
-         * The HTTP method. You can use an asterisk (*) as a wildcard to apply method settings to multiple methods.
+         * The HTTP method. To apply settings to multiple resources and methods, specify an asterisk (``*``) for the ``HttpMethod`` and ``/*`` for the ``ResourcePath``. This parameter is required when you specify a ``MethodSetting``.
          */
         httpMethod?: pulumi.Input<string>;
         /**
-         * The logging level for this method. For valid values, see the loggingLevel property of the Stage (https://docs.aws.amazon.com/apigateway/api-reference/resource/stage/#loggingLevel) resource in the Amazon API Gateway API Reference.
+         * Specifies the logging level for this method, which affects the log entries pushed to Amazon CloudWatch Logs. Valid values are ``OFF``, ``ERROR``, and ``INFO``. Choose ``ERROR`` to write only error-level entries to CloudWatch Logs, or choose ``INFO`` to include all ``ERROR`` events as well as extra informational events.
          */
         loggingLevel?: pulumi.Input<string>;
         /**
-         * Indicates whether Amazon CloudWatch metrics are enabled for methods in the stage.
+         * Specifies whether Amazon CloudWatch metrics are enabled for this method.
          */
         metricsEnabled?: pulumi.Input<boolean>;
         /**
-         * The resource path for this method. Forward slashes (/) are encoded as ~1 and the initial slash must include a forward slash. For example, the path value /resource/subresource must be encoded as /~1resource~1subresource. To specify the root path, use only a slash (/). You can use an asterisk (*) as a wildcard to apply method settings to multiple methods.
+         * The resource path for this method. Forward slashes (``/``) are encoded as ``~1`` and the initial slash must include a forward slash. For example, the path value ``/resource/subresource`` must be encoded as ``/~1resource~1subresource``. To specify the root path, use only a slash (``/``). To apply settings to multiple resources and methods, specify an asterisk (``*``) for the ``HttpMethod`` and ``/*`` for the ``ResourcePath``. This parameter is required when you specify a ``MethodSetting``.
          */
         resourcePath?: pulumi.Input<string>;
         /**
-         * The number of burst requests per second that API Gateway permits across all APIs, stages, and methods in your AWS account.
+         * Specifies the throttling burst limit.
          */
         throttlingBurstLimit?: pulumi.Input<number>;
         /**
-         * The number of steady-state requests per second that API Gateway permits across all APIs, stages, and methods in your AWS account.
+         * Specifies the throttling rate limit.
          */
         throttlingRateLimit?: pulumi.Input<number>;
     }
@@ -1785,9 +1849,18 @@ export declare namespace apigatewayv2 {
     }
 }
 export declare namespace appconfig {
+    /**
+     * Metadata to assign to the application. Tags help organize and categorize your AWS AppConfig resources. Each tag consists of a key and an optional value, both of which you define.
+     */
     interface ApplicationTagsArgs {
-        key?: pulumi.Input<string>;
-        value?: pulumi.Input<string>;
+        /**
+         * The key-value string map. The valid character set is [a-zA-Z1-9+-=._:/]. The tag key can be up to 128 characters and must not start with aws:.
+         */
+        key: pulumi.Input<string>;
+        /**
+         * The tag value can be up to 256 characters.
+         */
+        value: pulumi.Input<string>;
     }
     interface ConfigurationProfileTagsArgs {
         key?: pulumi.Input<string>;
@@ -4201,15 +4274,39 @@ export declare namespace appsync {
         rdsHttpEndpointConfig?: pulumi.Input<inputs.appsync.DataSourceRdsHttpEndpointConfigArgs>;
         relationalDatabaseSourceType: pulumi.Input<string>;
     }
+    /**
+     * Describes a runtime used by an AWS AppSync pipeline resolver or AWS AppSync function. Specifies the name and version of the runtime to use. Note that if a runtime is specified, code must also be specified.
+     */
     interface FunctionConfigurationAppSyncRuntimeArgs {
+        /**
+         * The name of the runtime to use. Currently, the only allowed value is APPSYNC_JS.
+         */
         name: pulumi.Input<string>;
+        /**
+         * The version of the runtime to use. Currently, the only allowed version is 1.0.0.
+         */
         runtimeVersion: pulumi.Input<string>;
     }
+    /**
+     * The LambdaConflictHandlerConfig when configuring LAMBDA as the Conflict Handler.
+     */
     interface FunctionConfigurationLambdaConflictHandlerConfigArgs {
+        /**
+         * The Amazon Resource Name (ARN) for the Lambda function to use as the Conflict Handler.
+         */
         lambdaConflictHandlerArn?: pulumi.Input<string>;
     }
+    /**
+     * Describes a Sync configuration for a resolver. Specifies which Conflict Detection strategy and Resolution strategy to use when the resolver is invoked.
+     */
     interface FunctionConfigurationSyncConfigArgs {
+        /**
+         * The Conflict Detection strategy to use.
+         */
         conflictDetection: pulumi.Input<string>;
+        /**
+         * The Conflict Resolution strategy to perform in the event of a conflict.
+         */
         conflictHandler?: pulumi.Input<string>;
         lambdaConflictHandlerConfig?: pulumi.Input<inputs.appsync.FunctionConfigurationLambdaConflictHandlerConfigArgs>;
     }
@@ -7014,8 +7111,8 @@ export declare namespace codestarnotifications {
 }
 export declare namespace cognito {
     interface IdentityPoolCognitoIdentityProviderArgs {
-        clientId: pulumi.Input<string>;
-        providerName: pulumi.Input<string>;
+        clientId?: pulumi.Input<string>;
+        providerName?: pulumi.Input<string>;
         serverSideTokenCheck?: pulumi.Input<boolean>;
     }
     interface IdentityPoolCognitoStreamsArgs {
@@ -7027,19 +7124,6 @@ export declare namespace cognito {
         applicationArns?: pulumi.Input<pulumi.Input<string>[]>;
         roleArn?: pulumi.Input<string>;
     }
-    /**
-     * A key-value pair to associate with a resource.
-     */
-    interface IdentityPoolTagArgs {
-        /**
-         * The key name of the tag. You can specify a value that is 1 to 128 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -.
-         */
-        key: pulumi.Input<string>;
-        /**
-         * The value for the tag. You can specify a value that is 0 to 256 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -.
-         */
-        value: pulumi.Input<string>;
-    }
     interface LogDeliveryConfigurationCloudWatchLogsConfigurationArgs {
         logGroupArn?: pulumi.Input<string>;
     }
@@ -8376,6 +8460,139 @@ export declare namespace customerprofiles {
         operator: pulumi.Input<enums.customerprofiles.CalculatedAttributeDefinitionThresholdOperator>;
         value: pulumi.Input<string>;
     }
+    /**
+     * Configures information about the AttributeTypesSelector where the rule-based identity resolution uses to match profiles.
+     */
+    interface DomainAttributeTypesSelectorArgs {
+        /**
+         * The Address type. You can choose from Address, BusinessAddress, MaillingAddress, and ShippingAddress. You only can use the Address type in the MatchingRule. For example, if you want to match profile based on BusinessAddress.City or MaillingAddress.City, you need to choose the BusinessAddress and the MaillingAddress to represent the Address type and specify the Address.City on the matching rule.
+         */
+        address?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Configures the AttributeMatchingModel, you can either choose ONE_TO_ONE or MANY_TO_MANY.
+         */
+        attributeMatchingModel: pulumi.Input<enums.customerprofiles.DomainAttributeTypesSelectorAttributeMatchingModel>;
+        /**
+         * The Email type. You can choose from EmailAddress, BusinessEmailAddress and PersonalEmailAddress. You only can use the EmailAddress type in the MatchingRule. For example, if you want to match profile based on PersonalEmailAddress or BusinessEmailAddress, you need to choose the PersonalEmailAddress and the BusinessEmailAddress to represent the EmailAddress type and only specify the EmailAddress on the matching rule.
+         */
+        emailAddress?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * The PhoneNumber type. You can choose from PhoneNumber, HomePhoneNumber, and MobilePhoneNumber. You only can use the PhoneNumber type in the MatchingRule. For example, if you want to match a profile based on Phone or HomePhone, you need to choose the Phone and the HomePhone to represent the PhoneNumber type and only specify the PhoneNumber on the matching rule.
+         */
+        phoneNumber?: pulumi.Input<pulumi.Input<string>[]>;
+    }
+    /**
+     * Configuration information about the auto-merging process.
+     */
+    interface DomainAutoMergingArgs {
+        conflictResolution?: pulumi.Input<inputs.customerprofiles.DomainConflictResolutionArgs>;
+        consolidation?: pulumi.Input<inputs.customerprofiles.DomainConsolidationArgs>;
+        /**
+         * The flag that enables the auto-merging of duplicate profiles.
+         */
+        enabled: pulumi.Input<boolean>;
+        /**
+         * A number between 0 and 1 that represents the minimum confidence score required for profiles within a matching group to be merged during the auto-merge process. A higher score means higher similarity required to merge profiles.
+         */
+        minAllowedConfidenceScoreForMerging?: pulumi.Input<number>;
+    }
+    /**
+     * How the auto-merging process should resolve conflicts between different profiles. For example, if Profile A and Profile B have the same FirstName and LastName (and that is the matching criteria), which EmailAddress should be used?
+     */
+    interface DomainConflictResolutionArgs {
+        /**
+         * How the auto-merging process should resolve conflicts between different profiles.
+         */
+        conflictResolvingModel: pulumi.Input<enums.customerprofiles.DomainConflictResolutionConflictResolvingModel>;
+        /**
+         * The ObjectType name that is used to resolve profile merging conflicts when choosing SOURCE as the ConflictResolvingModel.
+         */
+        sourceName?: pulumi.Input<string>;
+    }
+    /**
+     * A list of matching attributes that represent matching criteria. If two profiles meet at least one of the requirements in the matching attributes list, they will be merged.
+     */
+    interface DomainConsolidationArgs {
+        /**
+         * A list of matching criteria.
+         */
+        matchingAttributesList: pulumi.Input<pulumi.Input<pulumi.Input<string>[]>[]>;
+    }
+    /**
+     * Configuration information for exporting Identity Resolution results, for example, to an S3 bucket.
+     */
+    interface DomainExportingConfigArgs {
+        s3Exporting?: pulumi.Input<inputs.customerprofiles.DomainS3ExportingConfigArgs>;
+    }
+    /**
+     * The day and time when do you want to start the Identity Resolution Job every week.
+     */
+    interface DomainJobScheduleArgs {
+        /**
+         * The day when the Identity Resolution Job should run every week.
+         */
+        dayOfTheWeek: pulumi.Input<enums.customerprofiles.DomainJobScheduleDayOfTheWeek>;
+        /**
+         * The time when the Identity Resolution Job should run every week.
+         */
+        time: pulumi.Input<string>;
+    }
+    /**
+     * The process of matching duplicate profiles. If Matching = true, Amazon Connect Customer Profiles starts a weekly batch process called Identity Resolution Job. If you do not specify a date and time for Identity Resolution Job to run, by default it runs every Saturday at 12AM UTC to detect duplicate profiles in your domains. After the Identity Resolution Job completes, use the GetMatches API to return and review the results. Or, if you have configured ExportingConfig in the MatchingRequest, you can download the results from S3.
+     */
+    interface DomainMatchingArgs {
+        autoMerging?: pulumi.Input<inputs.customerprofiles.DomainAutoMergingArgs>;
+        /**
+         * The flag that enables the matching process of duplicate profiles.
+         */
+        enabled: pulumi.Input<boolean>;
+        exportingConfig?: pulumi.Input<inputs.customerprofiles.DomainExportingConfigArgs>;
+        jobSchedule?: pulumi.Input<inputs.customerprofiles.DomainJobScheduleArgs>;
+    }
+    /**
+     * Specifies how does the rule-based matching process should match profiles.
+     */
+    interface DomainMatchingRuleArgs {
+        rule: pulumi.Input<pulumi.Input<string>[]>;
+    }
+    /**
+     * The process of matching duplicate profiles using the Rule-Based matching. If RuleBasedMatching = true, Amazon Connect Customer Profiles will start to match and merge your profiles according to your configuration in the RuleBasedMatchingRequest. You can use the ListRuleBasedMatches and GetSimilarProfiles API to return and review the results. Also, if you have configured ExportingConfig in the RuleBasedMatchingRequest, you can download the results from S3.
+     */
+    interface DomainRuleBasedMatchingArgs {
+        attributeTypesSelector?: pulumi.Input<inputs.customerprofiles.DomainAttributeTypesSelectorArgs>;
+        conflictResolution?: pulumi.Input<inputs.customerprofiles.DomainConflictResolutionArgs>;
+        /**
+         * The flag that enables the rule-based matching process of duplicate profiles.
+         */
+        enabled: pulumi.Input<boolean>;
+        exportingConfig?: pulumi.Input<inputs.customerprofiles.DomainExportingConfigArgs>;
+        /**
+         * Configures how the rule-based matching process should match profiles. You can have up to 15 MatchingRule in the MatchingRules.
+         */
+        matchingRules?: pulumi.Input<pulumi.Input<inputs.customerprofiles.DomainMatchingRuleArgs>[]>;
+        /**
+         * Indicates the maximum allowed rule level for matching.
+         */
+        maxAllowedRuleLevelForMatching?: pulumi.Input<number>;
+        /**
+         * Indicates the maximum allowed rule level for merging.
+         */
+        maxAllowedRuleLevelForMerging?: pulumi.Input<number>;
+        status?: pulumi.Input<enums.customerprofiles.DomainRuleBasedMatchingStatus>;
+    }
+    /**
+     * The S3 location where Identity Resolution Jobs write result files.
+     */
+    interface DomainS3ExportingConfigArgs {
+        /**
+         * The name of the S3 bucket where Identity Resolution Jobs write result files.
+         */
+        s3BucketName: pulumi.Input<string>;
+        /**
+         * The S3 key name of the location where Identity Resolution Jobs write result files.
+         */
+        s3KeyName?: pulumi.Input<string>;
+    }
     interface DomainTagArgs {
         key: pulumi.Input<string>;
         value: pulumi.Input<string>;
@@ -14285,6 +14502,54 @@ export declare namespace emrserverless {
     }
 }
 export declare namespace entityresolution {
+    interface IdMappingWorkflowIdMappingTechniquesArgs {
+        idMappingType?: pulumi.Input<enums.entityresolution.IdMappingWorkflowIdMappingTechniquesIdMappingType>;
+        providerProperties?: pulumi.Input<inputs.entityresolution.IdMappingWorkflowProviderPropertiesArgs>;
+    }
+    interface IdMappingWorkflowInputSourceArgs {
+        /**
+         * An Glue table ARN for the input source table
+         */
+        inputSourceArn: pulumi.Input<string>;
+        schemaArn: pulumi.Input<string>;
+    }
+    interface IdMappingWorkflowIntermediateSourceConfigurationArgs {
+        /**
+         * The s3 path that would be used to stage the intermediate data being generated during workflow execution.
+         */
+        intermediateS3Path: pulumi.Input<string>;
+    }
+    interface IdMappingWorkflowOutputSourceArgs {
+        kmsArn?: pulumi.Input<string>;
+        /**
+         * The S3 path to which Entity Resolution will write the output table
+         */
+        outputS3Path: pulumi.Input<string>;
+    }
+    interface IdMappingWorkflowProviderPropertiesArgs {
+        intermediateSourceConfiguration?: pulumi.Input<inputs.entityresolution.IdMappingWorkflowIntermediateSourceConfigurationArgs>;
+        /**
+         * Additional Provider configuration that would be required for the provider service. The Configuration must be in JSON string format
+         */
+        providerConfiguration?: any;
+        /**
+         * Arn of the Provider Service being used.
+         */
+        providerServiceArn: pulumi.Input<string>;
+    }
+    /**
+     * A key-value pair to associate with a resource
+     */
+    interface IdMappingWorkflowTagArgs {
+        /**
+         * The key name of the tag. You can specify a value that is 1 to 128 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -.
+         */
+        key: pulumi.Input<string>;
+        /**
+         * The value for the tag. You can specify a value that is 0 to 256 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -.
+         */
+        value: pulumi.Input<string>;
+    }
     interface MatchingWorkflowInputSourceArgs {
         applyNormalization?: pulumi.Input<boolean>;
         /**
@@ -14505,7 +14770,6 @@ export declare namespace events {
         dbUser?: pulumi.Input<string>;
         secretManagerArn?: pulumi.Input<string>;
         sql?: pulumi.Input<string>;
-        sqls?: pulumi.Input<pulumi.Input<string>[]>;
         statementName?: pulumi.Input<string>;
         withEvent?: pulumi.Input<boolean>;
     }
@@ -16864,7 +17128,13 @@ export declare namespace healthlake {
 }
 export declare namespace iam {
     interface GroupPolicyArgs {
-        policyDocument: any;
+        /**
+         * The policy document.
+         */
+        policyDocument: pulumi.Input<string>;
+        /**
+         * The friendly name (not ARN) identifying the policy.
+         */
         policyName: pulumi.Input<string>;
     }
     /**
@@ -17900,6 +18170,10 @@ export declare namespace iot {
     interface MitigationActionUpdateDeviceCertificateParamsArgs {
         action: pulumi.Input<enums.iot.MitigationActionUpdateDeviceCertificateParamsAction>;
     }
+    interface PolicyTagArgs {
+        key: pulumi.Input<string>;
+        value: pulumi.Input<string>;
+    }
     /**
      * Configuration for pre-signed S3 URLs.
      */
@@ -27404,6 +27678,113 @@ export declare namespace msk {
         description?: pulumi.Input<string>;
         revision?: pulumi.Input<number>;
     }
+    /**
+     * Details of an Amazon MSK cluster.
+     */
+    interface ReplicatorAmazonMskClusterArgs {
+        /**
+         * The ARN of an Amazon MSK cluster.
+         */
+        mskClusterArn: pulumi.Input<string>;
+    }
+    /**
+     * Configuration relating to consumer group replication.
+     */
+    interface ReplicatorConsumerGroupReplicationArgs {
+        /**
+         * List of regular expression patterns indicating the consumer groups that should not be replicated.
+         */
+        consumerGroupsToExclude?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * List of regular expression patterns indicating the consumer groups to copy.
+         */
+        consumerGroupsToReplicate: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Whether to periodically check for new consumer groups.
+         */
+        detectAndCopyNewConsumerGroups?: pulumi.Input<boolean>;
+        /**
+         * Whether to periodically write the translated offsets to __consumer_offsets topic in target cluster.
+         */
+        synchroniseConsumerGroupOffsets?: pulumi.Input<boolean>;
+    }
+    /**
+     * Details of a Kafka cluster for replication.
+     */
+    interface ReplicatorKafkaClusterArgs {
+        /**
+         * Details of an Amazon MSK cluster. Exactly one of AmazonMskCluster is required.
+         */
+        amazonMskCluster: pulumi.Input<inputs.msk.ReplicatorAmazonMskClusterArgs>;
+        /**
+         * Details of an Amazon VPC which has network connectivity to the Apache Kafka cluster.
+         */
+        vpcConfig: pulumi.Input<inputs.msk.ReplicatorKafkaClusterClientVpcConfigArgs>;
+    }
+    /**
+     * Details of an Amazon VPC which has network connectivity to the Kafka cluster.
+     */
+    interface ReplicatorKafkaClusterClientVpcConfigArgs {
+        /**
+         * The AWS security groups to associate with the elastic network interfaces in order to specify what the replicator has access to. If a security group is not specified, the default security group associated with the VPC is used.
+         */
+        securityGroupIds?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * The list of subnets to connect to in the virtual private cloud (VPC). AWS creates elastic network interfaces inside these subnets.
+         */
+        subnetIds: pulumi.Input<pulumi.Input<string>[]>;
+    }
+    /**
+     * Specifies configuration for replication between a source and target Kafka cluster.
+     */
+    interface ReplicatorReplicationInfoArgs {
+        /**
+         * Configuration relating to consumer group replication.
+         */
+        consumerGroupReplication: pulumi.Input<inputs.msk.ReplicatorConsumerGroupReplicationArgs>;
+        /**
+         * Amazon Resource Name of the source Kafka cluster.
+         */
+        sourceKafkaClusterArn: pulumi.Input<string>;
+        /**
+         * The type of compression to use writing records to target Kafka cluster.
+         */
+        targetCompressionType: pulumi.Input<enums.msk.ReplicatorReplicationInfoTargetCompressionType>;
+        /**
+         * Amazon Resource Name of the target Kafka cluster.
+         */
+        targetKafkaClusterArn: pulumi.Input<string>;
+        /**
+         * Configuration relating to topic replication.
+         */
+        topicReplication: pulumi.Input<inputs.msk.ReplicatorTopicReplicationArgs>;
+    }
+    interface ReplicatorTagArgs {
+        key: pulumi.Input<string>;
+        value: pulumi.Input<string>;
+    }
+    interface ReplicatorTopicReplicationArgs {
+        /**
+         * Whether to periodically configure remote topic ACLs to match their corresponding upstream topics.
+         */
+        copyAccessControlListsForTopics?: pulumi.Input<boolean>;
+        /**
+         * Whether to periodically configure remote topics to match their corresponding upstream topics.
+         */
+        copyTopicConfigurations?: pulumi.Input<boolean>;
+        /**
+         * Whether to periodically check for new topics and partitions.
+         */
+        detectAndCopyNewTopics?: pulumi.Input<boolean>;
+        /**
+         * List of regular expression patterns indicating the topics that should not be replicated.
+         */
+        topicsToExclude?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * List of regular expression patterns indicating the topics to copy.
+         */
+        topicsToReplicate: pulumi.Input<pulumi.Input<string>[]>;
+    }
     interface ServerlessClusterClientAuthenticationArgs {
         sasl: pulumi.Input<inputs.msk.ServerlessClusterSaslArgs>;
     }
@@ -32242,6 +32623,9 @@ export declare namespace quicksight {
         computationId: pulumi.Input<string>;
         name?: pulumi.Input<string>;
     }
+    interface AnalysisValidationStrategyArgs {
+        mode: pulumi.Input<enums.quicksight.AnalysisValidationStrategyMode>;
+    }
     interface AnalysisVisibleRangeOptionsArgs {
         percentRange?: pulumi.Input<inputs.quicksight.AnalysisPercentVisibleRangeArgs>;
     }
@@ -34803,6 +35187,9 @@ export declare namespace quicksight {
         computationId: pulumi.Input<string>;
         name?: pulumi.Input<string>;
     }
+    interface DashboardValidationStrategyArgs {
+        mode: pulumi.Input<enums.quicksight.DashboardValidationStrategyMode>;
+    }
     interface DashboardVersionDefinitionArgs {
         analysisDefaults?: pulumi.Input<inputs.quicksight.DashboardAnalysisDefaultsArgs>;
         calculatedFields?: pulumi.Input<pulumi.Input<inputs.quicksight.DashboardCalculatedFieldArgs>[]>;
@@ -38057,6 +38444,9 @@ export declare namespace quicksight {
         computationId: pulumi.Input<string>;
         name?: pulumi.Input<string>;
     }
+    interface TemplateValidationStrategyArgs {
+        mode: pulumi.Input<enums.quicksight.TemplateValidationStrategyMode>;
+    }
     interface TemplateVersionDefinitionArgs {
         analysisDefaults?: pulumi.Input<inputs.quicksight.TemplateAnalysisDefaultsArgs>;
         calculatedFields?: pulumi.Input<pulumi.Input<inputs.quicksight.TemplateCalculatedFieldArgs>[]>;
@@ -39948,38 +40338,17 @@ export declare namespace s3 {
          */
         vpcId?: pulumi.Input<string>;
     }
-    /**
-     * Specifies the days since the initiation of an incomplete multipart upload that Amazon S3 will wait before permanently removing all parts of the upload.
-     */
     interface BucketAbortIncompleteMultipartUploadArgs {
-        /**
-         * Specifies the number of days after which Amazon S3 aborts an incomplete multipart upload.
-         */
         daysAfterInitiation: pulumi.Input<number>;
     }
     interface BucketAccelerateConfigurationArgs {
-        /**
-         * Configures the transfer acceleration state for an Amazon S3 bucket.
-         */
-        accelerationStatus: pulumi.Input<enums.s3.BucketAccelerateConfigurationAccelerationStatus>;
+        accelerationStatus: pulumi.Input<string>;
     }
-    /**
-     * Specify this only in a cross-account scenario (where source and destination bucket owners are not the same), and you want to change replica ownership to the AWS account that owns the destination bucket. If this is not specified in the replication configuration, the replicas are owned by same AWS account that owns the source object.
-     */
     interface BucketAccessControlTranslationArgs {
         owner: pulumi.Input<string>;
     }
-    /**
-     * Specifies the configuration and any analyses for the analytics filter of an Amazon S3 bucket.
-     */
     interface BucketAnalyticsConfigurationArgs {
-        /**
-         * The ID that identifies the analytics configuration.
-         */
         id: pulumi.Input<string>;
-        /**
-         * The prefix that an object must have to be included in the analytics results.
-         */
         prefix?: pulumi.Input<string>;
         storageClassAnalysis: pulumi.Input<inputs.s3.BucketStorageClassAnalysisArgs>;
         tagFilters?: pulumi.Input<pulumi.Input<inputs.s3.BucketTagFilterArgs>[]>;
@@ -39987,193 +40356,76 @@ export declare namespace s3 {
     interface BucketCorsConfigurationArgs {
         corsRules: pulumi.Input<pulumi.Input<inputs.s3.BucketCorsRuleArgs>[]>;
     }
-    /**
-     * A set of origins and methods (cross-origin access that you want to allow). You can add up to 100 rules to the configuration.
-     */
     interface BucketCorsRuleArgs {
-        /**
-         * Headers that are specified in the Access-Control-Request-Headers header.
-         */
         allowedHeaders?: pulumi.Input<pulumi.Input<string>[]>;
-        /**
-         * An HTTP method that you allow the origin to execute.
-         */
-        allowedMethods: pulumi.Input<pulumi.Input<enums.s3.BucketCorsRuleAllowedMethodsItem>[]>;
-        /**
-         * One or more origins you want customers to be able to access the bucket from.
-         */
+        allowedMethods: pulumi.Input<pulumi.Input<string>[]>;
         allowedOrigins: pulumi.Input<pulumi.Input<string>[]>;
-        /**
-         * One or more headers in the response that you want customers to be able to access from their applications (for example, from a JavaScript XMLHttpRequest object).
-         */
         exposedHeaders?: pulumi.Input<pulumi.Input<string>[]>;
-        /**
-         * A unique identifier for this rule.
-         */
         id?: pulumi.Input<string>;
-        /**
-         * The time in seconds that your browser is to cache the preflight response for the specified resource.
-         */
         maxAge?: pulumi.Input<number>;
     }
-    /**
-     * Specifies how data related to the storage class analysis for an Amazon S3 bucket should be exported.
-     */
     interface BucketDataExportArgs {
         destination: pulumi.Input<inputs.s3.BucketDestinationArgs>;
-        /**
-         * The version of the output schema to use when exporting data.
-         */
         outputSchemaVersion: pulumi.Input<string>;
     }
-    /**
-     * The default retention period that you want to apply to new objects placed in the specified bucket.
-     */
     interface BucketDefaultRetentionArgs {
         days?: pulumi.Input<number>;
-        mode?: pulumi.Input<enums.s3.BucketDefaultRetentionMode>;
+        mode?: pulumi.Input<string>;
         years?: pulumi.Input<number>;
     }
     interface BucketDeleteMarkerReplicationArgs {
-        status?: pulumi.Input<enums.s3.BucketDeleteMarkerReplicationStatus>;
+        status?: pulumi.Input<string>;
     }
-    /**
-     * Specifies information about where to publish analysis or configuration results for an Amazon S3 bucket and S3 Replication Time Control (S3 RTC).
-     */
     interface BucketDestinationArgs {
-        /**
-         * The account ID that owns the destination S3 bucket.
-         */
         bucketAccountId?: pulumi.Input<string>;
-        /**
-         * The Amazon Resource Name (ARN) of the bucket to which data is exported.
-         */
         bucketArn: pulumi.Input<string>;
-        /**
-         * Specifies the file format used when exporting data to Amazon S3.
-         */
-        format: pulumi.Input<enums.s3.BucketDestinationFormat>;
-        /**
-         * The prefix to use when exporting data. The prefix is prepended to all results.
-         */
+        format: pulumi.Input<string>;
         prefix?: pulumi.Input<string>;
     }
-    /**
-     * Specifies default encryption for a bucket using server-side encryption with either Amazon S3-managed keys (SSE-S3) or AWS KMS-managed keys (SSE-KMS).
-     */
     interface BucketEncryptionArgs {
-        /**
-         * Specifies the default server-side-encryption configuration.
-         */
         serverSideEncryptionConfiguration: pulumi.Input<pulumi.Input<inputs.s3.BucketServerSideEncryptionRuleArgs>[]>;
     }
-    /**
-     * Specifies encryption-related information for an Amazon S3 bucket that is a destination for replicated objects.
-     */
     interface BucketEncryptionConfigurationArgs {
-        /**
-         * Specifies the ID (Key ARN or Alias ARN) of the customer managed customer master key (CMK) stored in AWS Key Management Service (KMS) for the destination bucket.
-         */
         replicaKmsKeyId: pulumi.Input<string>;
     }
-    /**
-     * Describes the Amazon EventBridge notification configuration for an Amazon S3 bucket.
-     */
     interface BucketEventBridgeConfigurationArgs {
-        /**
-         * Specifies whether to send notifications to Amazon EventBridge when events occur in an Amazon S3 bucket.
-         */
-        eventBridgeEnabled: pulumi.Input<boolean>;
+        eventBridgeEnabled?: pulumi.Input<boolean>;
     }
-    /**
-     * Specifies the Amazon S3 object key name to filter on and whether to filter on the suffix or prefix of the key name.
-     */
     interface BucketFilterRuleArgs {
         name: pulumi.Input<string>;
         value: pulumi.Input<string>;
     }
     interface BucketIntelligentTieringConfigurationArgs {
-        /**
-         * The ID used to identify the S3 Intelligent-Tiering configuration.
-         */
         id: pulumi.Input<string>;
-        /**
-         * An object key name prefix that identifies the subset of objects to which the rule applies.
-         */
         prefix?: pulumi.Input<string>;
-        /**
-         * Specifies the status of the configuration.
-         */
-        status: pulumi.Input<enums.s3.BucketIntelligentTieringConfigurationStatus>;
-        /**
-         * A container for a key-value pair.
-         */
+        status: pulumi.Input<string>;
         tagFilters?: pulumi.Input<pulumi.Input<inputs.s3.BucketTagFilterArgs>[]>;
-        /**
-         * Specifies a list of S3 Intelligent-Tiering storage class tiers in the configuration. At least one tier must be defined in the list. At most, you can specify two tiers in the list, one for each available AccessTier: ARCHIVE_ACCESS and DEEP_ARCHIVE_ACCESS.
-         */
         tierings: pulumi.Input<pulumi.Input<inputs.s3.BucketTieringArgs>[]>;
     }
     interface BucketInventoryConfigurationArgs {
         destination: pulumi.Input<inputs.s3.BucketDestinationArgs>;
-        /**
-         * Specifies whether the inventory is enabled or disabled.
-         */
         enabled: pulumi.Input<boolean>;
-        /**
-         * The ID used to identify the inventory configuration.
-         */
         id: pulumi.Input<string>;
-        /**
-         * Object versions to include in the inventory list.
-         */
-        includedObjectVersions: pulumi.Input<enums.s3.BucketInventoryConfigurationIncludedObjectVersions>;
-        /**
-         * Contains the optional fields that are included in the inventory results.
-         */
-        optionalFields?: pulumi.Input<pulumi.Input<enums.s3.BucketInventoryConfigurationOptionalFieldsItem>[]>;
-        /**
-         * The prefix that is prepended to all inventory results.
-         */
+        includedObjectVersions: pulumi.Input<string>;
+        optionalFields?: pulumi.Input<pulumi.Input<string>[]>;
         prefix?: pulumi.Input<string>;
-        /**
-         * Specifies the schedule for generating inventory results.
-         */
-        scheduleFrequency: pulumi.Input<enums.s3.BucketInventoryConfigurationScheduleFrequency>;
+        scheduleFrequency: pulumi.Input<string>;
     }
-    /**
-     * Describes the AWS Lambda functions to invoke and the events for which to invoke them.
-     */
     interface BucketLambdaConfigurationArgs {
-        /**
-         * The Amazon S3 bucket event for which to invoke the AWS Lambda function.
-         */
         event: pulumi.Input<string>;
-        /**
-         * The filtering rules that determine which objects invoke the AWS Lambda function.
-         */
         filter?: pulumi.Input<inputs.s3.BucketNotificationFilterArgs>;
-        /**
-         * The Amazon Resource Name (ARN) of the AWS Lambda function that Amazon S3 invokes when the specified event type occurs.
-         */
         function: pulumi.Input<string>;
     }
     interface BucketLifecycleConfigurationArgs {
-        /**
-         * A lifecycle rule for individual objects in an Amazon S3 bucket.
-         */
         rules: pulumi.Input<pulumi.Input<inputs.s3.BucketRuleArgs>[]>;
     }
     interface BucketLoggingConfigurationArgs {
-        /**
-         * The name of an Amazon S3 bucket where Amazon S3 store server access log files. You can store log files in any bucket that you own. By default, logs are stored in the bucket where the LoggingConfiguration property is defined.
-         */
         destinationBucketName?: pulumi.Input<string>;
         logFilePrefix?: pulumi.Input<string>;
     }
     interface BucketMetricsArgs {
         eventThreshold?: pulumi.Input<inputs.s3.BucketReplicationTimeValueArgs>;
-        status: pulumi.Input<enums.s3.BucketMetricsStatus>;
+        status: pulumi.Input<string>;
     }
     interface BucketMetricsConfigurationArgs {
         accessPointArn?: pulumi.Input<string>;
@@ -40181,48 +40433,21 @@ export declare namespace s3 {
         prefix?: pulumi.Input<string>;
         tagFilters?: pulumi.Input<pulumi.Input<inputs.s3.BucketTagFilterArgs>[]>;
     }
-    /**
-     * Container for the expiration rule that describes when noncurrent objects are expired. If your bucket is versioning-enabled (or versioning is suspended), you can set this action to request that Amazon S3 expire noncurrent object versions at a specific period in the object's lifetime
-     */
     interface BucketNoncurrentVersionExpirationArgs {
-        /**
-         * Specified the number of newer noncurrent and current versions that must exists before performing the associated action
-         */
         newerNoncurrentVersions?: pulumi.Input<number>;
-        /**
-         * Specified the number of days an object is noncurrent before Amazon S3 can perform the associated action
-         */
         noncurrentDays: pulumi.Input<number>;
     }
-    /**
-     * Container for the transition rule that describes when noncurrent objects transition to the STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING, GLACIER_IR, GLACIER, or DEEP_ARCHIVE storage class. If your bucket is versioning-enabled (or versioning is suspended), you can set this action to request that Amazon S3 transition noncurrent object versions to the STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING, GLACIER_IR, GLACIER, or DEEP_ARCHIVE storage class at a specific period in the object's lifetime.
-     */
     interface BucketNoncurrentVersionTransitionArgs {
-        /**
-         * Specified the number of newer noncurrent and current versions that must exists before performing the associated action
-         */
         newerNoncurrentVersions?: pulumi.Input<number>;
-        /**
-         * The class of storage used to store the object.
-         */
-        storageClass: pulumi.Input<enums.s3.BucketNoncurrentVersionTransitionStorageClass>;
-        /**
-         * Specifies the number of days an object is noncurrent before Amazon S3 can perform the associated action.
-         */
+        storageClass: pulumi.Input<string>;
         transitionInDays: pulumi.Input<number>;
     }
-    /**
-     * Describes the notification configuration for an Amazon S3 bucket.
-     */
     interface BucketNotificationConfigurationArgs {
         eventBridgeConfiguration?: pulumi.Input<inputs.s3.BucketEventBridgeConfigurationArgs>;
         lambdaConfigurations?: pulumi.Input<pulumi.Input<inputs.s3.BucketLambdaConfigurationArgs>[]>;
         queueConfigurations?: pulumi.Input<pulumi.Input<inputs.s3.BucketQueueConfigurationArgs>[]>;
         topicConfigurations?: pulumi.Input<pulumi.Input<inputs.s3.BucketTopicConfigurationArgs>[]>;
     }
-    /**
-     * Specifies object key name filtering rules.
-     */
     interface BucketNotificationFilterArgs {
         s3Key: pulumi.Input<inputs.s3.BucketS3KeyFilterArgs>;
     }
@@ -40230,9 +40455,6 @@ export declare namespace s3 {
         objectLockEnabled?: pulumi.Input<string>;
         rule?: pulumi.Input<inputs.s3.BucketObjectLockRuleArgs>;
     }
-    /**
-     * The Object Lock rule in place for the specified object.
-     */
     interface BucketObjectLockRuleArgs {
         defaultRetention?: pulumi.Input<inputs.s3.BucketDefaultRetentionArgs>;
     }
@@ -40240,115 +40462,37 @@ export declare namespace s3 {
         rules: pulumi.Input<pulumi.Input<inputs.s3.BucketOwnershipControlsRuleArgs>[]>;
     }
     interface BucketOwnershipControlsRuleArgs {
-        /**
-         * Specifies an object ownership rule.
-         */
-        objectOwnership?: pulumi.Input<enums.s3.BucketOwnershipControlsRuleObjectOwnership>;
+        objectOwnership?: pulumi.Input<string>;
     }
-    /**
-     * Configuration that defines how Amazon S3 handles public access.
-     */
     interface BucketPublicAccessBlockConfigurationArgs {
-        /**
-         * Specifies whether Amazon S3 should block public access control lists (ACLs) for this bucket and objects in this bucket. Setting this element to TRUE causes the following behavior:
-         * - PUT Bucket acl and PUT Object acl calls fail if the specified ACL is public.
-         *  - PUT Object calls fail if the request includes a public ACL.
-         * Enabling this setting doesn't affect existing policies or ACLs.
-         */
         blockPublicAcls?: pulumi.Input<boolean>;
-        /**
-         * Specifies whether Amazon S3 should block public bucket policies for this bucket. Setting this element to TRUE causes Amazon S3 to reject calls to PUT Bucket policy if the specified bucket policy allows public access.
-         * Enabling this setting doesn't affect existing bucket policies.
-         */
         blockPublicPolicy?: pulumi.Input<boolean>;
-        /**
-         * Specifies whether Amazon S3 should ignore public ACLs for this bucket and objects in this bucket. Setting this element to TRUE causes Amazon S3 to ignore all public ACLs on this bucket and objects in this bucket.
-         * Enabling this setting doesn't affect the persistence of any existing ACLs and doesn't prevent new public ACLs from being set.
-         */
         ignorePublicAcls?: pulumi.Input<boolean>;
-        /**
-         * Specifies whether Amazon S3 should restrict public bucket policies for this bucket. Setting this element to TRUE restricts access to this bucket to only AWS services and authorized users within this account if the bucket has a public policy.
-         * Enabling this setting doesn't affect previously stored bucket policies, except that public and cross-account access within any public bucket policy, including non-public delegation to specific accounts, is blocked.
-         */
         restrictPublicBuckets?: pulumi.Input<boolean>;
     }
-    /**
-     * The Amazon Simple Queue Service queues to publish messages to and the events for which to publish messages.
-     */
     interface BucketQueueConfigurationArgs {
-        /**
-         * The Amazon S3 bucket event about which you want to publish messages to Amazon SQS.
-         */
         event: pulumi.Input<string>;
-        /**
-         * The filtering rules that determine which objects trigger notifications.
-         */
         filter?: pulumi.Input<inputs.s3.BucketNotificationFilterArgs>;
-        /**
-         * The Amazon Resource Name (ARN) of the Amazon SQS queue to which Amazon S3 publishes a message when it detects events of the specified type.
-         */
         queue: pulumi.Input<string>;
     }
-    /**
-     * Specifies the redirect behavior of all requests to a website endpoint of an Amazon S3 bucket.
-     */
     interface BucketRedirectAllRequestsToArgs {
-        /**
-         * Name of the host where requests are redirected.
-         */
         hostName: pulumi.Input<string>;
-        /**
-         * Protocol to use when redirecting requests. The default is the protocol that is used in the original request.
-         */
-        protocol?: pulumi.Input<enums.s3.BucketRedirectAllRequestsToProtocol>;
+        protocol?: pulumi.Input<string>;
     }
-    /**
-     * Specifies how requests are redirected. In the event of an error, you can specify a different error code to return.
-     */
     interface BucketRedirectRuleArgs {
-        /**
-         * The host name to use in the redirect request.
-         */
         hostName?: pulumi.Input<string>;
-        /**
-         * The HTTP redirect code to use on the response. Not required if one of the siblings is present.
-         */
         httpRedirectCode?: pulumi.Input<string>;
-        /**
-         * Protocol to use when redirecting requests. The default is the protocol that is used in the original request.
-         */
-        protocol?: pulumi.Input<enums.s3.BucketRedirectRuleProtocol>;
-        /**
-         * The object key prefix to use in the redirect request.
-         */
+        protocol?: pulumi.Input<string>;
         replaceKeyPrefixWith?: pulumi.Input<string>;
-        /**
-         * The specific object key to use in the redirect request.d
-         */
         replaceKeyWith?: pulumi.Input<string>;
     }
     interface BucketReplicaModificationsArgs {
-        /**
-         * Specifies whether Amazon S3 replicates modifications on replicas.
-         */
-        status: pulumi.Input<enums.s3.BucketReplicaModificationsStatus>;
+        status: pulumi.Input<string>;
     }
-    /**
-     * A container for replication rules. You can add up to 1,000 rules. The maximum size of a replication configuration is 2 MB.
-     */
     interface BucketReplicationConfigurationArgs {
-        /**
-         * The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM) role that Amazon S3 assumes when replicating objects.
-         */
         role: pulumi.Input<string>;
-        /**
-         * A container for one or more replication rules.
-         */
         rules: pulumi.Input<pulumi.Input<inputs.s3.BucketReplicationRuleArgs>[]>;
     }
-    /**
-     * Specifies which Amazon S3 bucket to store replicated objects in and their storage class.
-     */
     interface BucketReplicationDestinationArgs {
         accessControlTranslation?: pulumi.Input<inputs.s3.BucketAccessControlTranslationArgs>;
         account?: pulumi.Input<string>;
@@ -40356,32 +40500,17 @@ export declare namespace s3 {
         encryptionConfiguration?: pulumi.Input<inputs.s3.BucketEncryptionConfigurationArgs>;
         metrics?: pulumi.Input<inputs.s3.BucketMetricsArgs>;
         replicationTime?: pulumi.Input<inputs.s3.BucketReplicationTimeArgs>;
-        /**
-         * The storage class to use when replicating objects, such as S3 Standard or reduced redundancy.
-         */
-        storageClass?: pulumi.Input<enums.s3.BucketReplicationDestinationStorageClass>;
+        storageClass?: pulumi.Input<string>;
     }
-    /**
-     * Specifies which Amazon S3 objects to replicate and where to store the replicas.
-     */
     interface BucketReplicationRuleArgs {
         deleteMarkerReplication?: pulumi.Input<inputs.s3.BucketDeleteMarkerReplicationArgs>;
         destination: pulumi.Input<inputs.s3.BucketReplicationDestinationArgs>;
         filter?: pulumi.Input<inputs.s3.BucketReplicationRuleFilterArgs>;
-        /**
-         * A unique identifier for the rule.
-         */
         id?: pulumi.Input<string>;
-        /**
-         * An object key name prefix that identifies the object or objects to which the rule applies.
-         */
         prefix?: pulumi.Input<string>;
         priority?: pulumi.Input<number>;
         sourceSelectionCriteria?: pulumi.Input<inputs.s3.BucketSourceSelectionCriteriaArgs>;
-        /**
-         * Specifies whether the rule is enabled.
-         */
-        status: pulumi.Input<enums.s3.BucketReplicationRuleStatus>;
+        status: pulumi.Input<string>;
     }
     interface BucketReplicationRuleAndOperatorArgs {
         prefix?: pulumi.Input<string>;
@@ -40393,38 +40522,20 @@ export declare namespace s3 {
         tagFilter?: pulumi.Input<inputs.s3.BucketTagFilterArgs>;
     }
     interface BucketReplicationTimeArgs {
-        status: pulumi.Input<enums.s3.BucketReplicationTimeStatus>;
+        status: pulumi.Input<string>;
         time: pulumi.Input<inputs.s3.BucketReplicationTimeValueArgs>;
     }
     interface BucketReplicationTimeValueArgs {
         minutes: pulumi.Input<number>;
     }
-    /**
-     * Specifies the redirect behavior and when a redirect is applied.
-     */
     interface BucketRoutingRuleArgs {
-        /**
-         * Container for redirect information. You can redirect requests to another host, to another page, or with another protocol. In the event of an error, you can specify a different error code to return.
-         */
         redirectRule: pulumi.Input<inputs.s3.BucketRedirectRuleArgs>;
         routingRuleCondition?: pulumi.Input<inputs.s3.BucketRoutingRuleConditionArgs>;
     }
-    /**
-     * A container for describing a condition that must be met for the specified redirect to apply.You must specify at least one of HttpErrorCodeReturnedEquals and KeyPrefixEquals
-     */
     interface BucketRoutingRuleConditionArgs {
-        /**
-         * The HTTP error code when the redirect is applied.
-         */
         httpErrorCodeReturnedEquals?: pulumi.Input<string>;
-        /**
-         * The object key name prefix when the redirect is applied.
-         */
         keyPrefixEquals?: pulumi.Input<string>;
     }
-    /**
-     * You must specify at least one of the following properties: AbortIncompleteMultipartUpload, ExpirationDate, ExpirationInDays, NoncurrentVersionExpirationInDays, NoncurrentVersionTransition, NoncurrentVersionTransitions, Transition, or Transitions.
-     */
     interface BucketRuleArgs {
         abortIncompleteMultipartUpload?: pulumi.Input<inputs.s3.BucketAbortIncompleteMultipartUploadArgs>;
         expirationDate?: pulumi.Input<string>;
@@ -40435,65 +40546,32 @@ export declare namespace s3 {
         noncurrentVersionExpirationInDays?: pulumi.Input<number>;
         noncurrentVersionTransition?: pulumi.Input<inputs.s3.BucketNoncurrentVersionTransitionArgs>;
         noncurrentVersionTransitions?: pulumi.Input<pulumi.Input<inputs.s3.BucketNoncurrentVersionTransitionArgs>[]>;
-        objectSizeGreaterThan?: pulumi.Input<string>;
-        objectSizeLessThan?: pulumi.Input<string>;
+        objectSizeGreaterThan?: pulumi.Input<number>;
+        objectSizeLessThan?: pulumi.Input<number>;
         prefix?: pulumi.Input<string>;
-        status: pulumi.Input<enums.s3.BucketRuleStatus>;
+        status: pulumi.Input<string>;
         tagFilters?: pulumi.Input<pulumi.Input<inputs.s3.BucketTagFilterArgs>[]>;
         transition?: pulumi.Input<inputs.s3.BucketTransitionArgs>;
         transitions?: pulumi.Input<pulumi.Input<inputs.s3.BucketTransitionArgs>[]>;
     }
-    /**
-     * A container for object key name prefix and suffix filtering rules.
-     */
     interface BucketS3KeyFilterArgs {
         rules: pulumi.Input<pulumi.Input<inputs.s3.BucketFilterRuleArgs>[]>;
     }
-    /**
-     * Specifies the default server-side encryption to apply to new objects in the bucket. If a PUT Object request doesn't specify any server-side encryption, this default encryption will be applied.
-     */
     interface BucketServerSideEncryptionByDefaultArgs {
-        /**
-         * "KMSMasterKeyID" can only be used when you set the value of SSEAlgorithm as aws:kms or aws:kms:dsse.
-         */
         kmsMasterKeyId?: pulumi.Input<string>;
-        sseAlgorithm: pulumi.Input<enums.s3.BucketServerSideEncryptionByDefaultSseAlgorithm>;
+        sseAlgorithm: pulumi.Input<string>;
     }
-    /**
-     * Specifies the default server-side encryption configuration.
-     */
     interface BucketServerSideEncryptionRuleArgs {
-        /**
-         * Specifies whether Amazon S3 should use an S3 Bucket Key with server-side encryption using KMS (SSE-KMS) for new objects in the bucket. Existing objects are not affected. Setting the BucketKeyEnabled element to true causes Amazon S3 to use an S3 Bucket Key. By default, S3 Bucket Key is not enabled.
-         */
         bucketKeyEnabled?: pulumi.Input<boolean>;
         serverSideEncryptionByDefault?: pulumi.Input<inputs.s3.BucketServerSideEncryptionByDefaultArgs>;
     }
-    /**
-     * A container that describes additional filters for identifying the source objects that you want to replicate.
-     */
     interface BucketSourceSelectionCriteriaArgs {
-        /**
-         * A filter that you can specify for selection for modifications on replicas.
-         */
         replicaModifications?: pulumi.Input<inputs.s3.BucketReplicaModificationsArgs>;
-        /**
-         * A container for filter information for the selection of Amazon S3 objects encrypted with AWS KMS.
-         */
         sseKmsEncryptedObjects?: pulumi.Input<inputs.s3.BucketSseKmsEncryptedObjectsArgs>;
     }
-    /**
-     * A container for filter information for the selection of S3 objects encrypted with AWS KMS.
-     */
     interface BucketSseKmsEncryptedObjectsArgs {
-        /**
-         * Specifies whether Amazon S3 replicates objects created with server-side encryption using a customer master key (CMK) stored in AWS Key Management Service.
-         */
-        status: pulumi.Input<enums.s3.BucketSseKmsEncryptedObjectsStatus>;
+        status: pulumi.Input<string>;
     }
-    /**
-     * Specifies data related to access patterns to be collected and made available to analyze the tradeoffs between different storage classes for an Amazon S3 bucket.
-     */
     interface BucketStorageClassAnalysisArgs {
         dataExport?: pulumi.Input<inputs.s3.BucketDataExportArgs>;
     }
@@ -40501,68 +40579,29 @@ export declare namespace s3 {
         key: pulumi.Input<string>;
         value: pulumi.Input<string>;
     }
-    /**
-     * Tags to use to identify a subset of objects for an Amazon S3 bucket.
-     */
     interface BucketTagFilterArgs {
         key: pulumi.Input<string>;
         value: pulumi.Input<string>;
     }
     interface BucketTieringArgs {
-        /**
-         * S3 Intelligent-Tiering access tier. See Storage class for automatically optimizing frequently and infrequently accessed objects for a list of access tiers in the S3 Intelligent-Tiering storage class.
-         */
-        accessTier: pulumi.Input<enums.s3.BucketTieringAccessTier>;
-        /**
-         * The number of consecutive days of no access after which an object will be eligible to be transitioned to the corresponding tier. The minimum number of days specified for Archive Access tier must be at least 90 days and Deep Archive Access tier must be at least 180 days. The maximum can be up to 2 years (730 days).
-         */
+        accessTier: pulumi.Input<string>;
         days: pulumi.Input<number>;
     }
-    /**
-     * The topic to which notifications are sent and the events for which notifications are generated.
-     */
     interface BucketTopicConfigurationArgs {
-        /**
-         * The Amazon S3 bucket event about which to send notifications.
-         */
         event: pulumi.Input<string>;
-        /**
-         * The filtering rules that determine for which objects to send notifications.
-         */
         filter?: pulumi.Input<inputs.s3.BucketNotificationFilterArgs>;
-        /**
-         * The Amazon Resource Name (ARN) of the Amazon SNS topic to which Amazon S3 publishes a message when it detects events of the specified type.
-         */
         topic: pulumi.Input<string>;
     }
-    /**
-     * You must specify at least one of "TransitionDate" and "TransitionInDays"
-     */
     interface BucketTransitionArgs {
-        storageClass: pulumi.Input<enums.s3.BucketTransitionStorageClass>;
+        storageClass: pulumi.Input<string>;
         transitionDate?: pulumi.Input<string>;
         transitionInDays?: pulumi.Input<number>;
     }
-    /**
-     * Describes the versioning state of an Amazon S3 bucket.
-     */
     interface BucketVersioningConfigurationArgs {
-        /**
-         * The versioning state of the bucket.
-         */
-        status: pulumi.Input<enums.s3.BucketVersioningConfigurationStatus>;
+        status: pulumi.Input<string>;
     }
-    /**
-     * Specifies website configuration parameters for an Amazon S3 bucket.
-     */
     interface BucketWebsiteConfigurationArgs {
-        /**
-         * The name of the error document for the website.
-         */
         errorDocument?: pulumi.Input<string>;
-        /**
-         * The name of the index document for the website.
-         */
         indexDocument?: pulumi.Input<string>;
         redirectAllRequestsTo?: pulumi.Input<inputs.s3.BucketRedirectAllRequestsToArgs>;
         routingRules?: pulumi.Input<pulumi.Input<inputs.s3.BucketRoutingRuleArgs>[]>;
@@ -40967,6 +41006,10 @@ export declare namespace sagemaker {
          */
         dataCapturedDestinationS3Uri: pulumi.Input<string>;
         datasetFormat: pulumi.Input<inputs.sagemaker.DataQualityJobDefinitionDatasetFormatArgs>;
+        /**
+         * Indexes or names of the features to be excluded from analysis
+         */
+        excludeFeaturesAttribute?: pulumi.Input<string>;
         /**
          * Path to the filesystem where the endpoint data is available to the container.
          */
@@ -41076,6 +41119,10 @@ export declare namespace sagemaker {
      */
     interface DataQualityJobDefinitionEndpointInputArgs {
         endpointName: pulumi.Input<string>;
+        /**
+         * Indexes or names of the features to be excluded from analysis
+         */
+        excludeFeaturesAttribute?: pulumi.Input<string>;
         /**
          * Path to the filesystem where the endpoint data is available to the container.
          */
@@ -43336,6 +43383,10 @@ export declare namespace sagemaker {
          */
         dataCapturedDestinationS3Uri: pulumi.Input<string>;
         datasetFormat: pulumi.Input<inputs.sagemaker.MonitoringScheduleDatasetFormatArgs>;
+        /**
+         * Indexes or names of the features to be excluded from analysis
+         */
+        excludeFeaturesAttribute?: pulumi.Input<string>;
         /**
          * Path to the filesystem where the endpoint data is available to the container.
          */
@@ -43413,6 +43464,10 @@ export declare namespace sagemaker {
      */
     interface MonitoringScheduleEndpointInputArgs {
         endpointName: pulumi.Input<string>;
+        /**
+         * Indexes or names of the features to be excluded from analysis
+         */
+        excludeFeaturesAttribute?: pulumi.Input<string>;
         /**
          * Path to the filesystem where the endpoint data is available to the container.
          */
@@ -43579,7 +43634,15 @@ export declare namespace sagemaker {
      */
     interface MonitoringScheduleScheduleConfigArgs {
         /**
-         * A cron expression that describes details about the monitoring schedule.
+         * Data Analysis end time, e.g. PT0H
+         */
+        dataAnalysisEndTime?: pulumi.Input<string>;
+        /**
+         * Data Analysis start time, e.g. -PT1H
+         */
+        dataAnalysisStartTime?: pulumi.Input<string>;
+        /**
+         * A cron expression or 'NOW' that describes details about the monitoring schedule.
          */
         scheduleExpression: pulumi.Input<string>;
     }