AWS IoT FleetWise introduces new APIs for vision system data, such as…

… data collected from cameras, radars, and lidars. You can now model and decode complex data types.

This release launches Cost Optimization Hub, a new AWS Billing and Cost Management feature that helps you consolidate and prioritize cost optimization recommendations across your AWS Organizations member accounts and AWS Regions, so that you can get the most out of your AWS spend.
Adds a new 'type' property to the Setting structure. Adds a new AccountSetting - guardDutyActivate for ECS.
This release adds support for transcriptions from audio sources in 64 new languages and introduces generative call summarization in Transcribe Call Analytics (Post call)
CloudTrail Lake now supports federating event data stores. giving users the ability to run queries against their event data using Amazon Athena.
Initial release of AWS re:Post Private
Adding new params - Key and Prefix, to S3 API operations for supporting S3 Access Grants. Note - These updates will not change any of the existing S3 API functionality.
This release adds support for EKS Pod Identity feature. EKS Pod Identity makes it easy for customers to obtain IAM permissions for the applications running in their EKS clusters.
Adds and updates APIs to support customizable security controls. This feature allows Security Hub customers to provide custom parameters for security controls. With this release, findings for controls that support custom parameters will include the parameters used to generate the findings.
Introduce Amazon S3 Access Grants, a new S3 access control feature that maps identities in directories such as Active Directory, or AWS Identity and Access Management (IAM) Principals, to datasets in S3.
Add optional NetworkType property to Accessor APIs
This release enables AWS Compute Optimizer to analyze and generate recommendations with customization and discounts preferences.
Users can create, read, update, delete Exports of billing and cost management data.  Users can get details of Export Executions and details of Tables for exporting.  Tagging support is provided for Exports
The release introduces Multi-Region Resilience one-way data replication that allows you to replicate data from your primary WorkSpace to a standby WorkSpace in another AWS Region. DescribeWorkspaces now returns the status of data replication.
Support Periodic Recording for Configuration Recorder
Add support for Runtime Monitoring for ECS and ECS-EC2.
This release introduces new generative AI features in AWS Lex: Assisted Slot Resolution, Descriptive Bot Building, and Sample Utterance Generation. These features leverage large language models available through Amazon Bedrock to improve the bot builder and customer experiences.
This is the initial SDK release for the AWS Free Tier GetFreeTierUsage API
This release adds support for the Amazon Managed Service for Prometheus collector, a fully managed, agentless Prometheus metrics scraping capability.
AWS Secrets Manager has released the BatchGetSecretValue API, which allows customers to fetch up to 20 Secrets with a single request using a list of secret names or filters.
This release adds support for multi-data warehouse writes through data sharing.
This release launches new APIs for trusted identity propagation setup and supports creating datasources using trusted identity propagation as authentication method for QuickSight accounts configured with IAM Identity Center.
This release enables PutActions and PutActionInteractions
Enables metadata in recommendations and next best action recommendations
This release adds support for the CloudFormation Git sync feature. Git sync enables updating a CloudFormation stack from a template stored in a Git repository.
This release introduces support for interpretationSource in the runtime service response.
This release adds support for EKS Pod Identity feature. EKS Pod Identity makes it easy for customers to obtain IAM permissions for their applications running in the EKS clusters.
Added new APIs in Detective to support resource investigations
Added support for FSx for ONTAP scale-out file systems and FlexGroup volumes. Added the HAPairs field and ThroughputCapacityPerHAPair for filesystem. Added AggregateConfiguration (containing Aggregates and ConstituentsPerAggregate) and SizeInBytes for volume.
This release enables both mutual authentication (mTLS), and Automatic Target Weights (ATW) for Application Load Balancers.
Adding support for EFS Archive lifecycle configuration.
Initial release of Amazon WorkSpaces Thin Client
Enables metadata in recommendations, recommendations with themes, and next best action recommendations
This release adds four new APIs "DescribeLakeFormationIdentityCenterConfiguration", "CreateLakeFormationIdentityCenterConfiguration", "DescribeLakeFormationIdentityCenterConfiguration", and "DeleteLakeFormationIdentityCenterConfiguration", and also updates the corresponding documentation.
IAM Access Analyzer now continuously monitors IAM roles and users in your AWS account or organization to generate findings for unused access. Additionally, IAM Access Analyzer now provides custom policy checks to validate that IAM policies adhere to your security standards ahead of deployments.
Add APIs to create and manage a landing zone.
Added APIs to Create, Update, Get, List and Delete LogAnomalyDetectors and List and Update Anomalies in Detector. Added LogGroupClass attribute for LogGroups to classify loggroup as Standard loggroup with all capabilities or InfrequentAccess loggroup with limited capabilities.
Adds new TestState operation which accepts the definition of a single state and executes it. You can test a state without creating a state machine or updating an existing state machine.

VERSION

@@ -1 +1 @@
-1.11.208
+1.11.209

generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/AccessAnalyzerClient.h

@@ -16,20 +16,31 @@ namespace Aws
 namespace AccessAnalyzer
 {
   /**
-   * <p>Identity and Access Management Access Analyzer helps identify potential
-   * resource-access risks by enabling you to identify any policies that grant access
-   * to an external principal. It does this by using logic-based reasoning to analyze
-   * resource-based policies in your Amazon Web Services environment. An external
-   * principal can be another Amazon Web Services account, a root user, an IAM user
-   * or role, a federated user, an Amazon Web Services service, or an anonymous user.
-   * You can also use IAM Access Analyzer to preview and validate public and
-   * cross-account access to your resources before deploying permissions changes.
-   * This guide describes the Identity and Access Management Access Analyzer
-   * operations that you can call programmatically. For general information about IAM
-   * Access Analyzer, see <a
+   * <p>Identity and Access Management Access Analyzer helps you to set, verify, and
+   * refine your IAM policies by providing a suite of capabilities. Its features
+   * include findings for external and unused access, basic and custom policy checks
+   * for validating policies, and policy generation to generate fine-grained
+   * policies. To start using IAM Access Analyzer to identify external or unused
+   * access, you first need to create an analyzer.</p> <p> <b>External access
+   * analyzers</b> help identify potential risks of accessing resources by enabling
+   * you to identify any resource policies that grant access to an external
+   * principal. It does this by using logic-based reasoning to analyze resource-based
+   * policies in your Amazon Web Services environment. An external principal can be
+   * another Amazon Web Services account, a root user, an IAM user or role, a
+   * federated user, an Amazon Web Services service, or an anonymous user. You can
+   * also use IAM Access Analyzer to preview public and cross-account access to your
+   * resources before deploying permissions changes.</p> <p> <b>Unused access
+   * analyzers</b> help identify potential identity access risks by enabling you to
+   * identify unused IAM roles, unused access keys, unused console passwords, and IAM
+   * principals with unused service and action-level permissions.</p> <p>Beyond
+   * findings, IAM Access Analyzer provides basic and custom policy checks to
+   * validate IAM policies before deploying permissions changes. You can use policy
+   * generation to refine permissions by attaching a policy generated using access
+   * activity logged in CloudTrail logs. </p> <p>This guide describes the IAM Access
+   * Analyzer operations that you can call programmatically. For general information
+   * about IAM Access Analyzer, see <a
    * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html">Identity
    * and Access Management Access Analyzer</a> in the <b>IAM User Guide</b>.</p>
-   * <p>To start using IAM Access Analyzer, you first need to create an analyzer.</p>
    */
   class AWS_ACCESSANALYZER_API AccessAnalyzerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<AccessAnalyzerClient>
   {
@@ -140,6 +151,64 @@ namespace AccessAnalyzer
             return SubmitAsync(&AccessAnalyzerClient::CancelPolicyGeneration, request, handler, context);
         }
 
+        /**
+         * <p>Checks whether the specified access isn't allowed by a policy.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/accessanalyzer-2019-11-01/CheckAccessNotGranted">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::CheckAccessNotGrantedOutcome CheckAccessNotGranted(const Model::CheckAccessNotGrantedRequest& request) const;
+
+        /**
+         * A Callable wrapper for CheckAccessNotGranted that returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        template<typename CheckAccessNotGrantedRequestT = Model::CheckAccessNotGrantedRequest>
+        Model::CheckAccessNotGrantedOutcomeCallable CheckAccessNotGrantedCallable(const CheckAccessNotGrantedRequestT& request) const
+        {
+            return SubmitCallable(&AccessAnalyzerClient::CheckAccessNotGranted, request);
+        }
+
+        /**
+         * An Async wrapper for CheckAccessNotGranted that queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        template<typename CheckAccessNotGrantedRequestT = Model::CheckAccessNotGrantedRequest>
+        void CheckAccessNotGrantedAsync(const CheckAccessNotGrantedRequestT& request, const CheckAccessNotGrantedResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
+        {
+            return SubmitAsync(&AccessAnalyzerClient::CheckAccessNotGranted, request, handler, context);
+        }
+
+        /**
+         * <p>Checks whether new access is allowed for an updated policy when compared to
+         * the existing policy.</p> <p>You can find examples for reference policies and
+         * learn how to set up and run a custom policy check for new access in the <a
+         * href="https://github.com/aws-samples/iam-access-analyzer-custom-policy-check-samples">IAM
+         * Access Analyzer custom policy checks samples</a> repository on GitHub. The
+         * reference policies in this repository are meant to be passed to the
+         * <code>existingPolicyDocument</code> request parameter.</p><p><h3>See Also:</h3> 
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/accessanalyzer-2019-11-01/CheckNoNewAccess">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::CheckNoNewAccessOutcome CheckNoNewAccess(const Model::CheckNoNewAccessRequest& request) const;
+
+        /**
+         * A Callable wrapper for CheckNoNewAccess that returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        template<typename CheckNoNewAccessRequestT = Model::CheckNoNewAccessRequest>
+        Model::CheckNoNewAccessOutcomeCallable CheckNoNewAccessCallable(const CheckNoNewAccessRequestT& request) const
+        {
+            return SubmitCallable(&AccessAnalyzerClient::CheckNoNewAccess, request);
+        }
+
+        /**
+         * An Async wrapper for CheckNoNewAccess that queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        template<typename CheckNoNewAccessRequestT = Model::CheckNoNewAccessRequest>
+        void CheckNoNewAccessAsync(const CheckNoNewAccessRequestT& request, const CheckNoNewAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
+        {
+            return SubmitAsync(&AccessAnalyzerClient::CheckNoNewAccess, request, handler, context);
+        }
+
         /**
          * <p>Creates an access preview that allows you to preview IAM Access Analyzer
          * findings for your resource before deploying resource permissions.</p><p><h3>See
@@ -409,6 +478,32 @@ namespace AccessAnalyzer
             return SubmitAsync(&AccessAnalyzerClient::GetFinding, request, handler, context);
         }
 
+        /**
+         * <p>Retrieves information about the specified finding.</p><p><h3>See Also:</h3>  
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/accessanalyzer-2019-11-01/GetFindingV2">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetFindingV2Outcome GetFindingV2(const Model::GetFindingV2Request& request) const;
+
+        /**
+         * A Callable wrapper for GetFindingV2 that returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        template<typename GetFindingV2RequestT = Model::GetFindingV2Request>
+        Model::GetFindingV2OutcomeCallable GetFindingV2Callable(const GetFindingV2RequestT& request) const
+        {
+            return SubmitCallable(&AccessAnalyzerClient::GetFindingV2, request);
+        }
+
+        /**
+         * An Async wrapper for GetFindingV2 that queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        template<typename GetFindingV2RequestT = Model::GetFindingV2Request>
+        void GetFindingV2Async(const GetFindingV2RequestT& request, const GetFindingV2ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
+        {
+            return SubmitAsync(&AccessAnalyzerClient::GetFindingV2, request, handler, context);
+        }
+
         /**
          * <p>Retrieves the policy that was generated using
          * <code>StartPolicyGeneration</code>. </p><p><h3>See Also:</h3>   <a
@@ -593,6 +688,35 @@ namespace AccessAnalyzer
             return SubmitAsync(&AccessAnalyzerClient::ListFindings, request, handler, context);
         }
 
+        /**
+         * <p>Retrieves a list of findings generated by the specified analyzer.</p> <p>To
+         * learn about filter keys that you can use to retrieve a list of findings, see <a
+         * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-reference-filter-keys.html">IAM
+         * Access Analyzer filter keys</a> in the <b>IAM User Guide</b>.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/accessanalyzer-2019-11-01/ListFindingsV2">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListFindingsV2Outcome ListFindingsV2(const Model::ListFindingsV2Request& request) const;
+
+        /**
+         * A Callable wrapper for ListFindingsV2 that returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        template<typename ListFindingsV2RequestT = Model::ListFindingsV2Request>
+        Model::ListFindingsV2OutcomeCallable ListFindingsV2Callable(const ListFindingsV2RequestT& request) const
+        {
+            return SubmitCallable(&AccessAnalyzerClient::ListFindingsV2, request);
+        }
+
+        /**
+         * An Async wrapper for ListFindingsV2 that queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        template<typename ListFindingsV2RequestT = Model::ListFindingsV2Request>
+        void ListFindingsV2Async(const ListFindingsV2RequestT& request, const ListFindingsV2ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
+        {
+            return SubmitAsync(&AccessAnalyzerClient::ListFindingsV2, request, handler, context);
+        }
+
         /**
          * <p>Lists all of the policy generations requested in the last seven
          * days.</p><p><h3>See Also:</h3>   <a

generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/AccessAnalyzerErrors.h

@@ -49,7 +49,9 @@ enum class AccessAnalyzerErrors
 
   CONFLICT= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
   INTERNAL_SERVER,
-  SERVICE_QUOTA_EXCEEDED
+  INVALID_PARAMETER,
+  SERVICE_QUOTA_EXCEEDED,
+  UNPROCESSABLE_ENTITY
 };
 
 class AWS_ACCESSANALYZER_API AccessAnalyzerError : public Aws::Client::AWSError<AccessAnalyzerErrors>