This release adds support for just-In-time node access in AWS Systems Manager. Just-in-time node access enables customers to move towards zero standing privileges by requiring operators to request access and obtain approval before remotely connecting to nodes managed by the SSM Agent.

SageMaker Metrics Service now supports FIPS endpoint in all US and Canada Commercial regions.
AWS End User Messaging has added MONITOR and FILTER functionality to SMS Protect.
Add support for anonymous user access for Q Business applications
Introduces CustomEntity as part of the UserUnion data type. This field is used to indicate the entity who is performing the API action.
This release adds API support for the connection recording GUI Connect feature of AWS Systems Manager
Introduced support for P5en instance types on SageMaker Studio for JupyterLab and CodeEditor applications.
Amazon KDS now supports tagging and attribute-based access control (ABAC) for enhanced fan-out consumers.

Author: aws-sdk-cpp-automation

VERSION

@@ -1 +1 @@
-1.11.556
+1.11.557

generated/src/aws-cpp-sdk-connectcases/include/aws/connectcases/model/UserUnion.h

@@ -24,8 +24,8 @@ namespace Model
 {
 
   /**
-   * <p>Represents the identity of the person who performed the action.</p><p><h3>See
-   * Also:</h3>   <a
+   * <p>Represents the entity that performed the action.</p><p><h3>See Also:</h3>  
+   * <a
    * href="http://docs.aws.amazon.com/goto/WebAPI/connectcases-2022-10-03/UserUnion">AWS
    * API Reference</a></p>
    */
@@ -38,6 +38,18 @@ namespace Model
     AWS_CONNECTCASES_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
+    ///@{
+    /**
+     * <p>Any provided entity.</p>
+     */
+    inline const Aws::String& GetCustomEntity() const { return m_customEntity; }
+    inline bool CustomEntityHasBeenSet() const { return m_customEntityHasBeenSet; }
+    template<typename CustomEntityT = Aws::String>
+    void SetCustomEntity(CustomEntityT&& value) { m_customEntityHasBeenSet = true; m_customEntity = std::forward<CustomEntityT>(value); }
+    template<typename CustomEntityT = Aws::String>
+    UserUnion& WithCustomEntity(CustomEntityT&& value) { SetCustomEntity(std::forward<CustomEntityT>(value)); return *this;}
+    ///@}
+
     ///@{
     /**
      * <p>Represents the Amazon Connect ARN of the user.</p>
@@ -51,6 +63,9 @@ namespace Model
     ///@}
   private:
 
+    Aws::String m_customEntity;
+    bool m_customEntityHasBeenSet = false;
+
     Aws::String m_userArn;
     bool m_userArnHasBeenSet = false;
   };

generated/src/aws-cpp-sdk-connectcases/source/model/UserUnion.cpp

@@ -25,6 +25,11 @@ UserUnion::UserUnion(JsonView jsonValue)
 
 UserUnion& UserUnion::operator =(JsonView jsonValue)
 {
+  if(jsonValue.ValueExists("customEntity"))
+  {
+    m_customEntity = jsonValue.GetString("customEntity");
+    m_customEntityHasBeenSet = true;
+  }
   if(jsonValue.ValueExists("userArn"))
   {
     m_userArn = jsonValue.GetString("userArn");
@@ -37,6 +42,12 @@ JsonValue UserUnion::Jsonize() const
 {
   JsonValue payload;
 
+  if(m_customEntityHasBeenSet)
+  {
+   payload.WithString("customEntity", m_customEntity);
+
+  }
+
   if(m_userArnHasBeenSet)
   {
    payload.WithString("userArn", m_userArn);

generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisClient.h

@@ -149,11 +149,13 @@ namespace Kinesis
          * <p> <a>CreateStream</a> has a limit of five transactions per second per
          * account.</p> <p>You can add tags to the stream when making a
          * <code>CreateStream</code> request by setting the <code>Tags</code> parameter. If
-         * you pass <code>Tags</code> parameter, in addition to having
-         * <code>kinesis:createStream</code> permission, you must also have
-         * <code>kinesis:addTagsToStream</code> permission for the stream that will be
-         * created. Tags will take effect from the <code>CREATING</code> status of the
-         * stream. </p><p><h3>See Also:</h3>   <a
+         * you pass the <code>Tags</code> parameter, in addition to having the
+         * <code>kinesis:CreateStream</code> permission, you must also have the
+         * <code>kinesis:AddTagsToStream</code> permission for the stream that will be
+         * created. The <code>kinesis:TagResource</code> permission won’t work to tag
+         * streams on creation. Tags will take effect from the <code>CREATING</code> status
+         * of the stream, but you can't make any updates to the tags until the stream is in
+         * <code>ACTIVE</code> state.</p><p><h3>See Also:</h3>   <a
          * href="http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/CreateStream">AWS
          * API Reference</a></p>
          */
@@ -832,6 +834,36 @@ namespace Kinesis
             return SubmitAsync(&KinesisClient::ListStreams, request, handler, context);
         }
 
+        /**
+         * <p>List all tags added to the specified Kinesis resource. Each tag is a label
+         * consisting of a user-defined key and value. Tags can help you manage, identify,
+         * organize, search for, and filter resources.</p> <p>For more information about
+         * tagging Kinesis resources, see <a
+         * href="https://docs.aws.amazon.com/streams/latest/dev/tagging.html">Tag your
+         * Amazon Kinesis Data Streams resources</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/ListTagsForResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request = {}) const;
+
+        /**
+         * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
+        Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request = {}) const
+        {
+            return SubmitCallable(&KinesisClient::ListTagsForResource, request);
+        }
+
+        /**
+         * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
+        void ListTagsForResourceAsync(const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTagsForResourceRequestT& request = {}) const
+        {
+            return SubmitAsync(&KinesisClient::ListTagsForResource, request, handler, context);
+        }
+
         /**
          * <p>Lists the tags for the specified Kinesis data stream. This operation has a
          * limit of five transactions per second per account.</p>  <p>When invoking
@@ -1121,7 +1153,13 @@ namespace Kinesis
          * the consumer you register can then call <a>SubscribeToShard</a> to receive data
          * from the stream using enhanced fan-out, at a rate of up to 2 MiB per second for
          * every shard you subscribe to. This rate is unaffected by the total number of
-         * consumers that read from the same stream.</p> <p>You can register up to 20
+         * consumers that read from the same stream.</p> <p>You can add tags to the
+         * registered consumer when making a <code>RegisterStreamConsumer</code> request by
+         * setting the <code>Tags</code> parameter. If you pass the <code>Tags</code>
+         * parameter, in addition to having the <code>kinesis:RegisterStreamConsumer</code>
+         * permission, you must also have the <code>kinesis:TagResource</code> permission
+         * for the consumer that will be registered. Tags will take effect from the
+         * <code>CREATING</code> status of the consumer.</p> <p>You can register up to 20
          * consumers per stream. A given consumer can only be registered with one stream at
          * a time.</p> <p>For an example of how to use this operation, see <a
          * href="https://docs.aws.amazon.com/streams/latest/dev/building-enhanced-consumers-api.html">Enhanced
@@ -1390,6 +1428,61 @@ namespace Kinesis
             return SubmitAsync(&KinesisClient::SubscribeToShard, request, handler, context);
         }
 
+        /**
+         * <p>Adds or updates tags for the specified Kinesis resource. Each tag is a label
+         * consisting of a user-defined key and value. Tags can help you manage, identify,
+         * organize, search for, and filter resources. You can assign up to 50 tags to a
+         * Kinesis resource.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/TagResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
+
+        /**
+         * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        template<typename TagResourceRequestT = Model::TagResourceRequest>
+        Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const
+        {
+            return SubmitCallable(&KinesisClient::TagResource, request);
+        }
+
+        /**
+         * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        template<typename TagResourceRequestT = Model::TagResourceRequest>
+        void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
+        {
+            return SubmitAsync(&KinesisClient::TagResource, request, handler, context);
+        }
+
+        /**
+         * <p>Removes tags from the specified Kinesis resource. Removed tags are deleted
+         * and can't be recovered after this operation completes
+         * successfully.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/UntagResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
+
+        /**
+         * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
+        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
+        {
+            return SubmitCallable(&KinesisClient::UntagResource, request);
+        }
+
+        /**
+         * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
+        void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
+        {
+            return SubmitAsync(&KinesisClient::UntagResource, request, handler, context);
+        }
+
         /**
          * <p>Updates the shard count of the specified stream to the specified number of
          * shards. This API is only supported for the data streams with the provisioned

generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisServiceClientModel.h

@@ -30,6 +30,7 @@
 #include <aws/kinesis/model/ListShardsResult.h>
 #include <aws/kinesis/model/ListStreamConsumersResult.h>
 #include <aws/kinesis/model/ListStreamsResult.h>
+#include <aws/kinesis/model/ListTagsForResourceResult.h>
 #include <aws/kinesis/model/ListTagsForStreamResult.h>
 #include <aws/kinesis/model/PutRecordResult.h>
 #include <aws/kinesis/model/PutRecordsResult.h>
@@ -44,6 +45,7 @@
 #include <aws/kinesis/model/DescribeStreamConsumerRequest.h>
 #include <aws/kinesis/model/ListTagsForStreamRequest.h>
 #include <aws/kinesis/model/DescribeStreamRequest.h>
+#include <aws/kinesis/model/ListTagsForResourceRequest.h>
 #include <aws/core/NoResult.h>
 /* End of service model headers required in KinesisClient header */
 
@@ -104,6 +106,7 @@ namespace Aws
       class ListShardsRequest;
       class ListStreamConsumersRequest;
       class ListStreamsRequest;
+      class ListTagsForResourceRequest;
       class ListTagsForStreamRequest;
       class MergeShardsRequest;
       class PutRecordRequest;
@@ -115,6 +118,8 @@ namespace Aws
       class StartStreamEncryptionRequest;
       class StopStreamEncryptionRequest;
       class SubscribeToShardRequest;
+      class TagResourceRequest;
+      class UntagResourceRequest;
       class UpdateShardCountRequest;
       class UpdateStreamModeRequest;
       /* End of service model forward declarations required in KinesisClient header */
@@ -139,6 +144,7 @@ namespace Aws
       typedef Aws::Utils::Outcome<ListShardsResult, KinesisError> ListShardsOutcome;
       typedef Aws::Utils::Outcome<ListStreamConsumersResult, KinesisError> ListStreamConsumersOutcome;
       typedef Aws::Utils::Outcome<ListStreamsResult, KinesisError> ListStreamsOutcome;
+      typedef Aws::Utils::Outcome<ListTagsForResourceResult, KinesisError> ListTagsForResourceOutcome;
       typedef Aws::Utils::Outcome<ListTagsForStreamResult, KinesisError> ListTagsForStreamOutcome;
       typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> MergeShardsOutcome;
       typedef Aws::Utils::Outcome<PutRecordResult, KinesisError> PutRecordOutcome;
@@ -150,6 +156,8 @@ namespace Aws
       typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> StartStreamEncryptionOutcome;
       typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> StopStreamEncryptionOutcome;
       typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> SubscribeToShardOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> TagResourceOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> UntagResourceOutcome;
       typedef Aws::Utils::Outcome<UpdateShardCountResult, KinesisError> UpdateShardCountOutcome;
       typedef Aws::Utils::Outcome<Aws::NoResult, KinesisError> UpdateStreamModeOutcome;
       /* End of service model Outcome class definitions */
@@ -174,6 +182,7 @@ namespace Aws
       typedef std::future<ListShardsOutcome> ListShardsOutcomeCallable;
       typedef std::future<ListStreamConsumersOutcome> ListStreamConsumersOutcomeCallable;
       typedef std::future<ListStreamsOutcome> ListStreamsOutcomeCallable;
+      typedef std::future<ListTagsForResourceOutcome> ListTagsForResourceOutcomeCallable;
       typedef std::future<ListTagsForStreamOutcome> ListTagsForStreamOutcomeCallable;
       typedef std::future<MergeShardsOutcome> MergeShardsOutcomeCallable;
       typedef std::future<PutRecordOutcome> PutRecordOutcomeCallable;
@@ -185,6 +194,8 @@ namespace Aws
       typedef std::future<StartStreamEncryptionOutcome> StartStreamEncryptionOutcomeCallable;
       typedef std::future<StopStreamEncryptionOutcome> StopStreamEncryptionOutcomeCallable;
       typedef std::future<SubscribeToShardOutcome> SubscribeToShardOutcomeCallable;
+      typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable;
+      typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable;
       typedef std::future<UpdateShardCountOutcome> UpdateShardCountOutcomeCallable;
       typedef std::future<UpdateStreamModeOutcome> UpdateStreamModeOutcomeCallable;
       /* End of service model Outcome callable definitions */
@@ -212,6 +223,7 @@ namespace Aws
     typedef std::function<void(const KinesisClient*, const Model::ListShardsRequest&, const Model::ListShardsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListShardsResponseReceivedHandler;
     typedef std::function<void(const KinesisClient*, const Model::ListStreamConsumersRequest&, const Model::ListStreamConsumersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListStreamConsumersResponseReceivedHandler;
     typedef std::function<void(const KinesisClient*, const Model::ListStreamsRequest&, const Model::ListStreamsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListStreamsResponseReceivedHandler;
+    typedef std::function<void(const KinesisClient*, const Model::ListTagsForResourceRequest&, const Model::ListTagsForResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsForResourceResponseReceivedHandler;
     typedef std::function<void(const KinesisClient*, const Model::ListTagsForStreamRequest&, const Model::ListTagsForStreamOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsForStreamResponseReceivedHandler;
     typedef std::function<void(const KinesisClient*, const Model::MergeShardsRequest&, const Model::MergeShardsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > MergeShardsResponseReceivedHandler;
     typedef std::function<void(const KinesisClient*, const Model::PutRecordRequest&, const Model::PutRecordOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutRecordResponseReceivedHandler;
@@ -223,6 +235,8 @@ namespace Aws
     typedef std::function<void(const KinesisClient*, const Model::StartStreamEncryptionRequest&, const Model::StartStreamEncryptionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StartStreamEncryptionResponseReceivedHandler;
     typedef std::function<void(const KinesisClient*, const Model::StopStreamEncryptionRequest&, const Model::StopStreamEncryptionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StopStreamEncryptionResponseReceivedHandler;
     typedef std::function<void(const KinesisClient*, const Model::SubscribeToShardRequest&, const Model::SubscribeToShardOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SubscribeToShardResponseReceivedHandler;
+    typedef std::function<void(const KinesisClient*, const Model::TagResourceRequest&, const Model::TagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TagResourceResponseReceivedHandler;
+    typedef std::function<void(const KinesisClient*, const Model::UntagResourceRequest&, const Model::UntagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UntagResourceResponseReceivedHandler;
     typedef std::function<void(const KinesisClient*, const Model::UpdateShardCountRequest&, const Model::UpdateShardCountOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateShardCountResponseReceivedHandler;
     typedef std::function<void(const KinesisClient*, const Model::UpdateStreamModeRequest&, const Model::UpdateStreamModeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateStreamModeResponseReceivedHandler;
     /* End of service model async handlers definitions */

generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/model/AddTagsToStreamRequest.h

@@ -57,7 +57,9 @@ namespace Model
 
     ///@{
     /**
-     * <p>A set of up to 10 key-value pairs to use to create the tags.</p>
+     * <p>A set of up to 50 key-value pairs to use to create the tags. A tag consists
+     * of a required key and an optional value. You can add up to 50 tags per
+     * resource.</p>
      */
     inline const Aws::Map<Aws::String, Aws::String>& GetTags() const { return m_tags; }
     inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }

generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/model/CreateStreamRequest.h

@@ -85,7 +85,8 @@ namespace Model
 
     ///@{
     /**
-     * <p>A set of up to 10 key-value pairs to use to create the tags.</p>
+     * <p>A set of up to 50 key-value pairs to use to create the tags. A tag consists
+     * of a required key and an optional value.</p>
      */
     inline const Aws::Map<Aws::String, Aws::String>& GetTags() const { return m_tags; }
     inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }