Adds GroupConfiguration field to Identity Source API's

Adding support for X12 5010 HIPAA EDI version and associated transaction sets.
Amazon EC2 G6 instances powered by NVIDIA L4 Tensor Core GPUs can be used for a wide range of graphics-intensive and machine learning use cases. Gr6 instances also feature NVIDIA L4 GPUs and can be used for graphics workloads with higher memory requirements.
This release adds support for integration with EKS AccessEntry APIs to enable automatic Cluster Access for EMR on EKS.
Feature: New schemaStatusDetails field to the existing Schema object that displays a status on Schema API responses to show whether a schema is queryable or not. New BatchGetSchemaAnalysisRule API to retrieve multiple schemaAnalysisRules using a single API call.
API update to include an SRT ingest endpoint and passphrase for all channels.

VERSION

@@ -1 +1 @@
-1.11.300
+1.11.301

generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/model/X12TransactionSet.h

@@ -67,7 +67,30 @@ namespace Model
     X12_945,
     X12_990,
     X12_997,
-    X12_999
+    X12_999,
+    X12_270_X279,
+    X12_271_X279,
+    X12_275_X210,
+    X12_275_X211,
+    X12_276_X212,
+    X12_277_X212,
+    X12_277_X214,
+    X12_277_X364,
+    X12_278_X217,
+    X12_820_X218,
+    X12_820_X306,
+    X12_824_X186,
+    X12_834_X220,
+    X12_834_X307,
+    X12_834_X318,
+    X12_835_X221,
+    X12_837_X222,
+    X12_837_X223,
+    X12_837_X224,
+    X12_837_X291,
+    X12_837_X292,
+    X12_837_X298,
+    X12_999_X231
   };
 
 namespace X12TransactionSetMapper

generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/model/X12Version.h

@@ -18,7 +18,8 @@ namespace Model
     NOT_SET,
     VERSION_4010,
     VERSION_4030,
-    VERSION_5010
+    VERSION_5010,
+    VERSION_5010_HIPAA
   };
 
 namespace X12VersionMapper

generated/src/aws-cpp-sdk-b2bi/source/model/X12TransactionSet.cpp

@@ -72,6 +72,29 @@ namespace Aws
         static const int X12_990_HASH = HashingUtils::HashString("X12_990");
         static const int X12_997_HASH = HashingUtils::HashString("X12_997");
         static const int X12_999_HASH = HashingUtils::HashString("X12_999");
+        static const int X12_270_X279_HASH = HashingUtils::HashString("X12_270_X279");
+        static const int X12_271_X279_HASH = HashingUtils::HashString("X12_271_X279");
+        static const int X12_275_X210_HASH = HashingUtils::HashString("X12_275_X210");
+        static const int X12_275_X211_HASH = HashingUtils::HashString("X12_275_X211");
+        static const int X12_276_X212_HASH = HashingUtils::HashString("X12_276_X212");
+        static const int X12_277_X212_HASH = HashingUtils::HashString("X12_277_X212");
+        static const int X12_277_X214_HASH = HashingUtils::HashString("X12_277_X214");
+        static const int X12_277_X364_HASH = HashingUtils::HashString("X12_277_X364");
+        static const int X12_278_X217_HASH = HashingUtils::HashString("X12_278_X217");
+        static const int X12_820_X218_HASH = HashingUtils::HashString("X12_820_X218");
+        static const int X12_820_X306_HASH = HashingUtils::HashString("X12_820_X306");
+        static const int X12_824_X186_HASH = HashingUtils::HashString("X12_824_X186");
+        static const int X12_834_X220_HASH = HashingUtils::HashString("X12_834_X220");
+        static const int X12_834_X307_HASH = HashingUtils::HashString("X12_834_X307");
+        static const int X12_834_X318_HASH = HashingUtils::HashString("X12_834_X318");
+        static const int X12_835_X221_HASH = HashingUtils::HashString("X12_835_X221");
+        static const int X12_837_X222_HASH = HashingUtils::HashString("X12_837_X222");
+        static const int X12_837_X223_HASH = HashingUtils::HashString("X12_837_X223");
+        static const int X12_837_X224_HASH = HashingUtils::HashString("X12_837_X224");
+        static const int X12_837_X291_HASH = HashingUtils::HashString("X12_837_X291");
+        static const int X12_837_X292_HASH = HashingUtils::HashString("X12_837_X292");
+        static const int X12_837_X298_HASH = HashingUtils::HashString("X12_837_X298");
+        static const int X12_999_X231_HASH = HashingUtils::HashString("X12_999_X231");
 
 
         X12TransactionSet GetX12TransactionSetForName(const Aws::String& name)
@@ -285,6 +308,98 @@ namespace Aws
           {
             return X12TransactionSet::X12_999;
           }
+          else if (hashCode == X12_270_X279_HASH)
+          {
+            return X12TransactionSet::X12_270_X279;
+          }
+          else if (hashCode == X12_271_X279_HASH)
+          {
+            return X12TransactionSet::X12_271_X279;
+          }
+          else if (hashCode == X12_275_X210_HASH)
+          {
+            return X12TransactionSet::X12_275_X210;
+          }
+          else if (hashCode == X12_275_X211_HASH)
+          {
+            return X12TransactionSet::X12_275_X211;
+          }
+          else if (hashCode == X12_276_X212_HASH)
+          {
+            return X12TransactionSet::X12_276_X212;
+          }
+          else if (hashCode == X12_277_X212_HASH)
+          {
+            return X12TransactionSet::X12_277_X212;
+          }
+          else if (hashCode == X12_277_X214_HASH)
+          {
+            return X12TransactionSet::X12_277_X214;
+          }
+          else if (hashCode == X12_277_X364_HASH)
+          {
+            return X12TransactionSet::X12_277_X364;
+          }
+          else if (hashCode == X12_278_X217_HASH)
+          {
+            return X12TransactionSet::X12_278_X217;
+          }
+          else if (hashCode == X12_820_X218_HASH)
+          {
+            return X12TransactionSet::X12_820_X218;
+          }
+          else if (hashCode == X12_820_X306_HASH)
+          {
+            return X12TransactionSet::X12_820_X306;
+          }
+          else if (hashCode == X12_824_X186_HASH)
+          {
+            return X12TransactionSet::X12_824_X186;
+          }
+          else if (hashCode == X12_834_X220_HASH)
+          {
+            return X12TransactionSet::X12_834_X220;
+          }
+          else if (hashCode == X12_834_X307_HASH)
+          {
+            return X12TransactionSet::X12_834_X307;
+          }
+          else if (hashCode == X12_834_X318_HASH)
+          {
+            return X12TransactionSet::X12_834_X318;
+          }
+          else if (hashCode == X12_835_X221_HASH)
+          {
+            return X12TransactionSet::X12_835_X221;
+          }
+          else if (hashCode == X12_837_X222_HASH)
+          {
+            return X12TransactionSet::X12_837_X222;
+          }
+          else if (hashCode == X12_837_X223_HASH)
+          {
+            return X12TransactionSet::X12_837_X223;
+          }
+          else if (hashCode == X12_837_X224_HASH)
+          {
+            return X12TransactionSet::X12_837_X224;
+          }
+          else if (hashCode == X12_837_X291_HASH)
+          {
+            return X12TransactionSet::X12_837_X291;
+          }
+          else if (hashCode == X12_837_X292_HASH)
+          {
+            return X12TransactionSet::X12_837_X292;
+          }
+          else if (hashCode == X12_837_X298_HASH)
+          {
+            return X12TransactionSet::X12_837_X298;
+          }
+          else if (hashCode == X12_999_X231_HASH)
+          {
+            return X12TransactionSet::X12_999_X231;
+          }
           EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
           if(overflowContainer)
           {
@@ -405,6 +520,52 @@ namespace Aws
             return "X12_997";
           case X12TransactionSet::X12_999:
             return "X12_999";
+          case X12TransactionSet::X12_270_X279:
+            return "X12_270_X279";
+          case X12TransactionSet::X12_271_X279:
+            return "X12_271_X279";
+          case X12TransactionSet::X12_275_X210:
+            return "X12_275_X210";
+          case X12TransactionSet::X12_275_X211:
+            return "X12_275_X211";
+          case X12TransactionSet::X12_276_X212:
+            return "X12_276_X212";
+          case X12TransactionSet::X12_277_X212:
+            return "X12_277_X212";
+          case X12TransactionSet::X12_277_X214:
+            return "X12_277_X214";
+          case X12TransactionSet::X12_277_X364:
+            return "X12_277_X364";
+          case X12TransactionSet::X12_278_X217:
+            return "X12_278_X217";
+          case X12TransactionSet::X12_820_X218:
+            return "X12_820_X218";
+          case X12TransactionSet::X12_820_X306:
+            return "X12_820_X306";
+          case X12TransactionSet::X12_824_X186:
+            return "X12_824_X186";
+          case X12TransactionSet::X12_834_X220:
+            return "X12_834_X220";
+          case X12TransactionSet::X12_834_X307:
+            return "X12_834_X307";
+          case X12TransactionSet::X12_834_X318:
+            return "X12_834_X318";
+          case X12TransactionSet::X12_835_X221:
+            return "X12_835_X221";
+          case X12TransactionSet::X12_837_X222:
+            return "X12_837_X222";
+          case X12TransactionSet::X12_837_X223:
+            return "X12_837_X223";
+          case X12TransactionSet::X12_837_X224:
+            return "X12_837_X224";
+          case X12TransactionSet::X12_837_X291:
+            return "X12_837_X291";
+          case X12TransactionSet::X12_837_X292:
+            return "X12_837_X292";
+          case X12TransactionSet::X12_837_X298:
+            return "X12_837_X298";
+          case X12TransactionSet::X12_999_X231:
+            return "X12_999_X231";
           default:
             EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
             if(overflowContainer)

generated/src/aws-cpp-sdk-b2bi/source/model/X12Version.cpp

@@ -23,6 +23,7 @@ namespace Aws
         static const int VERSION_4010_HASH = HashingUtils::HashString("VERSION_4010");
         static const int VERSION_4030_HASH = HashingUtils::HashString("VERSION_4030");
         static const int VERSION_5010_HASH = HashingUtils::HashString("VERSION_5010");
+        static const int VERSION_5010_HIPAA_HASH = HashingUtils::HashString("VERSION_5010_HIPAA");
 
 
         X12Version GetX12VersionForName(const Aws::String& name)
@@ -40,6 +41,10 @@ namespace Aws
           {
             return X12Version::VERSION_5010;
           }
+          else if (hashCode == VERSION_5010_HIPAA_HASH)
+          {
+            return X12Version::VERSION_5010_HIPAA;
+          }
           EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
           if(overflowContainer)
           {
@@ -62,6 +67,8 @@ namespace Aws
             return "VERSION_4030";
           case X12Version::VERSION_5010:
             return "VERSION_5010";
+          case X12Version::VERSION_5010_HIPAA:
+            return "VERSION_5010_HIPAA";
           default:
             EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
             if(overflowContainer)

generated/src/aws-cpp-sdk-cleanrooms/include/aws/cleanrooms/CleanRoomsClient.h

@@ -139,6 +139,31 @@ namespace CleanRooms
             return SubmitAsync(&CleanRoomsClient::BatchGetSchema, request, handler, context);
         }
 
+        /**
+         * <p>Retrieves multiple analysis rule schemas.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/cleanrooms-2022-02-17/BatchGetSchemaAnalysisRule">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::BatchGetSchemaAnalysisRuleOutcome BatchGetSchemaAnalysisRule(const Model::BatchGetSchemaAnalysisRuleRequest& request) const;
+
+        /**
+         * A Callable wrapper for BatchGetSchemaAnalysisRule that returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        template<typename BatchGetSchemaAnalysisRuleRequestT = Model::BatchGetSchemaAnalysisRuleRequest>
+        Model::BatchGetSchemaAnalysisRuleOutcomeCallable BatchGetSchemaAnalysisRuleCallable(const BatchGetSchemaAnalysisRuleRequestT& request) const
+        {
+            return SubmitCallable(&CleanRoomsClient::BatchGetSchemaAnalysisRule, request);
+        }
+
+        /**
+         * An Async wrapper for BatchGetSchemaAnalysisRule that queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        template<typename BatchGetSchemaAnalysisRuleRequestT = Model::BatchGetSchemaAnalysisRuleRequest>
+        void BatchGetSchemaAnalysisRuleAsync(const BatchGetSchemaAnalysisRuleRequestT& request, const BatchGetSchemaAnalysisRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
+        {
+            return SubmitAsync(&CleanRoomsClient::BatchGetSchemaAnalysisRule, request, handler, context);
+        }
+
         /**
          * <p>Creates a new analysis template.</p><p><h3>See Also:</h3>   <a
          * href="http://docs.aws.amazon.com/goto/WebAPI/cleanrooms-2022-02-17/CreateAnalysisTemplate">AWS

generated/src/aws-cpp-sdk-cleanrooms/include/aws/cleanrooms/CleanRoomsServiceClientModel.h

@@ -20,6 +20,7 @@
 /* Service model headers required in CleanRoomsClient header */
 #include <aws/cleanrooms/model/BatchGetCollaborationAnalysisTemplateResult.h>
 #include <aws/cleanrooms/model/BatchGetSchemaResult.h>
+#include <aws/cleanrooms/model/BatchGetSchemaAnalysisRuleResult.h>
 #include <aws/cleanrooms/model/CreateAnalysisTemplateResult.h>
 #include <aws/cleanrooms/model/CreateCollaborationResult.h>
 #include <aws/cleanrooms/model/CreateConfiguredAudienceModelAssociationResult.h>
@@ -122,6 +123,7 @@ namespace Aws
       /* Service model forward declarations required in CleanRoomsClient header */
       class BatchGetCollaborationAnalysisTemplateRequest;
       class BatchGetSchemaRequest;
+      class BatchGetSchemaAnalysisRuleRequest;
       class CreateAnalysisTemplateRequest;
       class CreateCollaborationRequest;
       class CreateConfiguredAudienceModelAssociationRequest;
@@ -187,6 +189,7 @@ namespace Aws
       /* Service model Outcome class definitions */
       typedef Aws::Utils::Outcome<BatchGetCollaborationAnalysisTemplateResult, CleanRoomsError> BatchGetCollaborationAnalysisTemplateOutcome;
       typedef Aws::Utils::Outcome<BatchGetSchemaResult, CleanRoomsError> BatchGetSchemaOutcome;
+      typedef Aws::Utils::Outcome<BatchGetSchemaAnalysisRuleResult, CleanRoomsError> BatchGetSchemaAnalysisRuleOutcome;
       typedef Aws::Utils::Outcome<CreateAnalysisTemplateResult, CleanRoomsError> CreateAnalysisTemplateOutcome;
       typedef Aws::Utils::Outcome<CreateCollaborationResult, CleanRoomsError> CreateCollaborationOutcome;
       typedef Aws::Utils::Outcome<CreateConfiguredAudienceModelAssociationResult, CleanRoomsError> CreateConfiguredAudienceModelAssociationOutcome;
@@ -252,6 +255,7 @@ namespace Aws
       /* Service model Outcome callable definitions */
       typedef std::future<BatchGetCollaborationAnalysisTemplateOutcome> BatchGetCollaborationAnalysisTemplateOutcomeCallable;
       typedef std::future<BatchGetSchemaOutcome> BatchGetSchemaOutcomeCallable;
+      typedef std::future<BatchGetSchemaAnalysisRuleOutcome> BatchGetSchemaAnalysisRuleOutcomeCallable;
       typedef std::future<CreateAnalysisTemplateOutcome> CreateAnalysisTemplateOutcomeCallable;
       typedef std::future<CreateCollaborationOutcome> CreateCollaborationOutcomeCallable;
       typedef std::future<CreateConfiguredAudienceModelAssociationOutcome> CreateConfiguredAudienceModelAssociationOutcomeCallable;
@@ -320,6 +324,7 @@ namespace Aws
     /* Service model async handlers definitions */
     typedef std::function<void(const CleanRoomsClient*, const Model::BatchGetCollaborationAnalysisTemplateRequest&, const Model::BatchGetCollaborationAnalysisTemplateOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > BatchGetCollaborationAnalysisTemplateResponseReceivedHandler;
     typedef std::function<void(const CleanRoomsClient*, const Model::BatchGetSchemaRequest&, const Model::BatchGetSchemaOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > BatchGetSchemaResponseReceivedHandler;
+    typedef std::function<void(const CleanRoomsClient*, const Model::BatchGetSchemaAnalysisRuleRequest&, const Model::BatchGetSchemaAnalysisRuleOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > BatchGetSchemaAnalysisRuleResponseReceivedHandler;
     typedef std::function<void(const CleanRoomsClient*, const Model::CreateAnalysisTemplateRequest&, const Model::CreateAnalysisTemplateOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateAnalysisTemplateResponseReceivedHandler;
     typedef std::function<void(const CleanRoomsClient*, const Model::CreateCollaborationRequest&, const Model::CreateCollaborationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateCollaborationResponseReceivedHandler;
     typedef std::function<void(const CleanRoomsClient*, const Model::CreateConfiguredAudienceModelAssociationRequest&, const Model::CreateConfiguredAudienceModelAssociationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateConfiguredAudienceModelAssociationResponseReceivedHandler;