Adds support for OAuth 2.0 token operations in AWS Sign-In, CreateOAuth2TokenWithIAM (client credentials flow), IntrospectOAuth2TokenWithIAM (token inspection), and RevokeOAuth2TokenWithIAM (token revocation).

Author: aws-sdk-cpp-automation

VERSION

@@ -1 +1 @@
-1.11.842
+1.11.843

generated/src/aws-cpp-sdk-signin/include/aws/signin/SigninClient.h

@@ -124,6 +124,35 @@ class AWS_SIGNIN_API SigninClient : public Aws::Client::AWSJsonClient,
     return SubmitAsync(&SigninClient::CreateOAuth2Token, request, handler, context);
   }
 
+  /**
+   * <p>Grants permission to exchange client credentials for an OAuth 2.0 access
+   * token scoped to a resource that can be used to access AWS services from
+   * applications</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/signin-2023-01-01/CreateOAuth2TokenWithIAM">AWS
+   * API Reference</a></p>
+   */
+  virtual Model::CreateOAuth2TokenWithIAMOutcome CreateOAuth2TokenWithIAM(const Model::CreateOAuth2TokenWithIAMRequest& request) const;
+
+  /**
+   * A Callable wrapper for CreateOAuth2TokenWithIAM that returns a future to the operation so that it can be executed in parallel to other
+   * requests.
+   */
+  template <typename CreateOAuth2TokenWithIAMRequestT = Model::CreateOAuth2TokenWithIAMRequest>
+  Model::CreateOAuth2TokenWithIAMOutcomeCallable CreateOAuth2TokenWithIAMCallable(const CreateOAuth2TokenWithIAMRequestT& request) const {
+    return SubmitCallable(&SigninClient::CreateOAuth2TokenWithIAM, request);
+  }
+
+  /**
+   * An Async wrapper for CreateOAuth2TokenWithIAM that queues the request into a thread executor and triggers associated callback when
+   * operation has finished.
+   */
+  template <typename CreateOAuth2TokenWithIAMRequestT = Model::CreateOAuth2TokenWithIAMRequest>
+  void CreateOAuth2TokenWithIAMAsync(const CreateOAuth2TokenWithIAMRequestT& request,
+                                     const CreateOAuth2TokenWithIAMResponseReceivedHandler& handler,
+                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
+    return SubmitAsync(&SigninClient::CreateOAuth2TokenWithIAM, request, handler, context);
+  }
+
   /**
    * <p>Delete console authorization configuration with automatic scope
    * detection</p><p><h3>See Also:</h3>   <a
@@ -242,6 +271,42 @@ class AWS_SIGNIN_API SigninClient : public Aws::Client::AWSJsonClient,
     return SubmitAsync(&SigninClient::GetResourcePolicy, request, handler, context);
   }
 
+  /**
+   * <p>Grants permission to inspect the metadata and state of an OAuth 2.0 access
+   * token or refresh token</p> <p>Implements RFC 7662 OAuth 2.0 Token Introspection
+   * over a SigV4-authenticated endpoint. Inspects the metadata of an access_token or
+   * refresh_token issued by AWS Sign-In and returns the claims associated with
+   * it.</p> <p>Inactive token semantics (RFC 7662 §2.2): when the supplied token is
+   * unknown, expired, revoked, malformed, or owned by a different account, the
+   * response body is exactly { &quot;active&quot;: false } with all other claims
+   * omitted.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/signin-2023-01-01/IntrospectOAuth2TokenWithIAM">AWS
+   * API Reference</a></p>
+   */
+  virtual Model::IntrospectOAuth2TokenWithIAMOutcome IntrospectOAuth2TokenWithIAM(
+      const Model::IntrospectOAuth2TokenWithIAMRequest& request) const;
+
+  /**
+   * A Callable wrapper for IntrospectOAuth2TokenWithIAM that returns a future to the operation so that it can be executed in parallel to
+   * other requests.
+   */
+  template <typename IntrospectOAuth2TokenWithIAMRequestT = Model::IntrospectOAuth2TokenWithIAMRequest>
+  Model::IntrospectOAuth2TokenWithIAMOutcomeCallable IntrospectOAuth2TokenWithIAMCallable(
+      const IntrospectOAuth2TokenWithIAMRequestT& request) const {
+    return SubmitCallable(&SigninClient::IntrospectOAuth2TokenWithIAM, request);
+  }
+
+  /**
+   * An Async wrapper for IntrospectOAuth2TokenWithIAM that queues the request into a thread executor and triggers associated callback when
+   * operation has finished.
+   */
+  template <typename IntrospectOAuth2TokenWithIAMRequestT = Model::IntrospectOAuth2TokenWithIAMRequest>
+  void IntrospectOAuth2TokenWithIAMAsync(const IntrospectOAuth2TokenWithIAMRequestT& request,
+                                         const IntrospectOAuth2TokenWithIAMResponseReceivedHandler& handler,
+                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
+    return SubmitAsync(&SigninClient::IntrospectOAuth2TokenWithIAM, request, handler, context);
+  }
+
   /**
    * <p>Retrieve all permission statements in the account's SignIn resource-based
    * policy</p><p><h3>See Also:</h3>   <a
@@ -332,6 +397,38 @@ class AWS_SIGNIN_API SigninClient : public Aws::Client::AWSJsonClient,
     return SubmitAsync(&SigninClient::PutResourcePermissionStatement, request, handler, context);
   }
 
+  /**
+   * <p>Grants permission to revoke an OAuth 2.0 refresh token and its associated
+   * refresh tokens</p> <p>Revokes a refresh_token issued by AWS Sign-In,
+   * invalidating the entire token chain so that the refresh_token can no longer be
+   * used to mint new access_tokens.</p> <p>Idempotency: revoking an already-revoked,
+   * expired, or otherwise invalid token still returns 200 OK with an empty body.
+   * Only the refresh_token type is accepted.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/signin-2023-01-01/RevokeOAuth2TokenWithIAM">AWS
+   * API Reference</a></p>
+   */
+  virtual Model::RevokeOAuth2TokenWithIAMOutcome RevokeOAuth2TokenWithIAM(const Model::RevokeOAuth2TokenWithIAMRequest& request) const;
+
+  /**
+   * A Callable wrapper for RevokeOAuth2TokenWithIAM that returns a future to the operation so that it can be executed in parallel to other
+   * requests.
+   */
+  template <typename RevokeOAuth2TokenWithIAMRequestT = Model::RevokeOAuth2TokenWithIAMRequest>
+  Model::RevokeOAuth2TokenWithIAMOutcomeCallable RevokeOAuth2TokenWithIAMCallable(const RevokeOAuth2TokenWithIAMRequestT& request) const {
+    return SubmitCallable(&SigninClient::RevokeOAuth2TokenWithIAM, request);
+  }
+
+  /**
+   * An Async wrapper for RevokeOAuth2TokenWithIAM that queues the request into a thread executor and triggers associated callback when
+   * operation has finished.
+   */
+  template <typename RevokeOAuth2TokenWithIAMRequestT = Model::RevokeOAuth2TokenWithIAMRequest>
+  void RevokeOAuth2TokenWithIAMAsync(const RevokeOAuth2TokenWithIAMRequestT& request,
+                                     const RevokeOAuth2TokenWithIAMResponseReceivedHandler& handler,
+                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
+    return SubmitAsync(&SigninClient::RevokeOAuth2TokenWithIAM, request, handler, context);
+  }
+
   virtual void OverrideEndpoint(const Aws::String& endpoint);
   virtual std::shared_ptr<SigninEndpointProviderBase>& accessEndpointProvider();
 

generated/src/aws-cpp-sdk-signin/include/aws/signin/SigninServiceClientModel.h

@@ -20,19 +20,22 @@
 
 /* Service model headers required in SigninClient header */
 #include <aws/signin/model/CreateOAuth2TokenResult.h>
+#include <aws/signin/model/CreateOAuth2TokenWithIAMResult.h>
 #include <aws/signin/model/DeleteConsoleAuthorizationConfigurationRequest.h>
 #include <aws/signin/model/DeleteConsoleAuthorizationConfigurationResult.h>
 #include <aws/signin/model/DeleteResourcePermissionStatementResult.h>
 #include <aws/signin/model/GetConsoleAuthorizationConfigurationRequest.h>
 #include <aws/signin/model/GetConsoleAuthorizationConfigurationResult.h>
 #include <aws/signin/model/GetResourcePolicyRequest.h>
 #include <aws/signin/model/GetResourcePolicyResult.h>
+#include <aws/signin/model/IntrospectOAuth2TokenWithIAMResult.h>
 #include <aws/signin/model/ListResourcePermissionStatementsRequest.h>
 #include <aws/signin/model/ListResourcePermissionStatementsResult.h>
 #include <aws/signin/model/PutConsoleAuthorizationConfigurationRequest.h>
 #include <aws/signin/model/PutConsoleAuthorizationConfigurationResult.h>
 #include <aws/signin/model/PutResourcePermissionStatementRequest.h>
 #include <aws/signin/model/PutResourcePermissionStatementResult.h>
+#include <aws/signin/model/RevokeOAuth2TokenWithIAMResult.h>
 /* End of service model headers required in SigninClient header */
 
 namespace Aws {
@@ -67,35 +70,44 @@ using SigninEndpointProvider = Aws::Signin::Endpoint::SigninEndpointProvider;
 namespace Model {
 /* Service model forward declarations required in SigninClient header */
 class CreateOAuth2TokenRequest;
+class CreateOAuth2TokenWithIAMRequest;
 class DeleteConsoleAuthorizationConfigurationRequest;
 class DeleteResourcePermissionStatementRequest;
 class GetConsoleAuthorizationConfigurationRequest;
 class GetResourcePolicyRequest;
+class IntrospectOAuth2TokenWithIAMRequest;
 class ListResourcePermissionStatementsRequest;
 class PutConsoleAuthorizationConfigurationRequest;
 class PutResourcePermissionStatementRequest;
+class RevokeOAuth2TokenWithIAMRequest;
 /* End of service model forward declarations required in SigninClient header */
 
 /* Service model Outcome class definitions */
 typedef Aws::Utils::Outcome<CreateOAuth2TokenResult, SigninError> CreateOAuth2TokenOutcome;
+typedef Aws::Utils::Outcome<CreateOAuth2TokenWithIAMResult, SigninError> CreateOAuth2TokenWithIAMOutcome;
 typedef Aws::Utils::Outcome<DeleteConsoleAuthorizationConfigurationResult, SigninError> DeleteConsoleAuthorizationConfigurationOutcome;
 typedef Aws::Utils::Outcome<DeleteResourcePermissionStatementResult, SigninError> DeleteResourcePermissionStatementOutcome;
 typedef Aws::Utils::Outcome<GetConsoleAuthorizationConfigurationResult, SigninError> GetConsoleAuthorizationConfigurationOutcome;
 typedef Aws::Utils::Outcome<GetResourcePolicyResult, SigninError> GetResourcePolicyOutcome;
+typedef Aws::Utils::Outcome<IntrospectOAuth2TokenWithIAMResult, SigninError> IntrospectOAuth2TokenWithIAMOutcome;
 typedef Aws::Utils::Outcome<ListResourcePermissionStatementsResult, SigninError> ListResourcePermissionStatementsOutcome;
 typedef Aws::Utils::Outcome<PutConsoleAuthorizationConfigurationResult, SigninError> PutConsoleAuthorizationConfigurationOutcome;
 typedef Aws::Utils::Outcome<PutResourcePermissionStatementResult, SigninError> PutResourcePermissionStatementOutcome;
+typedef Aws::Utils::Outcome<RevokeOAuth2TokenWithIAMResult, SigninError> RevokeOAuth2TokenWithIAMOutcome;
 /* End of service model Outcome class definitions */
 
 /* Service model Outcome callable definitions */
 typedef std::future<CreateOAuth2TokenOutcome> CreateOAuth2TokenOutcomeCallable;
+typedef std::future<CreateOAuth2TokenWithIAMOutcome> CreateOAuth2TokenWithIAMOutcomeCallable;
 typedef std::future<DeleteConsoleAuthorizationConfigurationOutcome> DeleteConsoleAuthorizationConfigurationOutcomeCallable;
 typedef std::future<DeleteResourcePermissionStatementOutcome> DeleteResourcePermissionStatementOutcomeCallable;
 typedef std::future<GetConsoleAuthorizationConfigurationOutcome> GetConsoleAuthorizationConfigurationOutcomeCallable;
 typedef std::future<GetResourcePolicyOutcome> GetResourcePolicyOutcomeCallable;
+typedef std::future<IntrospectOAuth2TokenWithIAMOutcome> IntrospectOAuth2TokenWithIAMOutcomeCallable;
 typedef std::future<ListResourcePermissionStatementsOutcome> ListResourcePermissionStatementsOutcomeCallable;
 typedef std::future<PutConsoleAuthorizationConfigurationOutcome> PutConsoleAuthorizationConfigurationOutcomeCallable;
 typedef std::future<PutResourcePermissionStatementOutcome> PutResourcePermissionStatementOutcomeCallable;
+typedef std::future<RevokeOAuth2TokenWithIAMOutcome> RevokeOAuth2TokenWithIAMOutcomeCallable;
 /* End of service model Outcome callable definitions */
 }  // namespace Model
 
@@ -105,6 +117,9 @@ class SigninClient;
 typedef std::function<void(const SigninClient*, const Model::CreateOAuth2TokenRequest&, const Model::CreateOAuth2TokenOutcome&,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
     CreateOAuth2TokenResponseReceivedHandler;
+typedef std::function<void(const SigninClient*, const Model::CreateOAuth2TokenWithIAMRequest&,
+                           const Model::CreateOAuth2TokenWithIAMOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
+    CreateOAuth2TokenWithIAMResponseReceivedHandler;
 typedef std::function<void(const SigninClient*, const Model::DeleteConsoleAuthorizationConfigurationRequest&,
                            const Model::DeleteConsoleAuthorizationConfigurationOutcome&,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
@@ -120,6 +135,10 @@ typedef std::function<void(const SigninClient*, const Model::GetConsoleAuthoriza
 typedef std::function<void(const SigninClient*, const Model::GetResourcePolicyRequest&, const Model::GetResourcePolicyOutcome&,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
     GetResourcePolicyResponseReceivedHandler;
+typedef std::function<void(const SigninClient*, const Model::IntrospectOAuth2TokenWithIAMRequest&,
+                           const Model::IntrospectOAuth2TokenWithIAMOutcome&,
+                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
+    IntrospectOAuth2TokenWithIAMResponseReceivedHandler;
 typedef std::function<void(const SigninClient*, const Model::ListResourcePermissionStatementsRequest&,
                            const Model::ListResourcePermissionStatementsOutcome&,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
@@ -132,6 +151,9 @@ typedef std::function<void(const SigninClient*, const Model::PutResourcePermissi
                            const Model::PutResourcePermissionStatementOutcome&,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
     PutResourcePermissionStatementResponseReceivedHandler;
+typedef std::function<void(const SigninClient*, const Model::RevokeOAuth2TokenWithIAMRequest&,
+                           const Model::RevokeOAuth2TokenWithIAMOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
+    RevokeOAuth2TokenWithIAMResponseReceivedHandler;
 /* End of service model async handlers definitions */
 }  // namespace Signin
 }  // namespace Aws

generated/src/aws-cpp-sdk-signin/include/aws/signin/model/AccessToken.h

@@ -20,10 +20,9 @@ namespace Signin {
 namespace Model {
 
 /**
- * <p>AWS credentials structure containing temporary access credentials</p> <p>The
- * scoped-down, 15 minute duration AWS credentials. Scoping down will be based on
- * CLI policy (CLI team needs to create it). Similar to cloud shell
- * implementation.</p><p><h3>See Also:</h3>   <a
+ * <p>AWS credentials structure containing temporary access credentials</p>
+ * <p>Scoped, temporary AWS credentials with a 15-minute duration.</p><p><h3>See
+ * Also:</h3>   <a
  * href="http://docs.aws.amazon.com/goto/WebAPI/signin-2023-01-01/AccessToken">AWS
  * API Reference</a></p>
  */

generated/src/aws-cpp-sdk-signin/include/aws/signin/model/CreateOAuth2TokenWithIAMRequest.h

@@ -0,0 +1,86 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/signin/SigninRequest.h>
+#include <aws/signin/Signin_EXPORTS.h>
+
+#include <utility>
+
+namespace Aws {
+namespace Signin {
+namespace Model {
+
+/**
+ * <p>Input structure for CreateOAuth2TokenWithIAM operation</p><p><h3>See
+ * Also:</h3>   <a
+ * href="http://docs.aws.amazon.com/goto/WebAPI/signin-2023-01-01/CreateOAuth2TokenWithIAMRequest">AWS
+ * API Reference</a></p>
+ */
+class CreateOAuth2TokenWithIAMRequest : public SigninRequest {
+ public:
+  AWS_SIGNIN_API CreateOAuth2TokenWithIAMRequest() = default;
+
+  // Service request name is the Operation name which will send this request out,
+  // each operation should has unique request name, so that we can get operation's name from this request.
+  // Note: this is not true for response, multiple operations may have the same response name,
+  // so we can not get operation's name from response.
+  inline virtual const char* GetServiceRequestName() const override { return "CreateOAuth2TokenWithIAM"; }
+
+  AWS_SIGNIN_API Aws::String SerializePayload() const override;
+
+  /**
+   * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+   */
+  AWS_SIGNIN_API EndpointParameters GetEndpointContextParams() const override;
+
+  ///@{
+  /**
+   * <p>OAuth 2.0 grant type. Must be &quot;client_credentials&quot;.</p>
+   */
+  inline const Aws::String& GetGrantType() const { return m_grantType; }
+  inline bool GrantTypeHasBeenSet() const { return m_grantTypeHasBeenSet; }
+  template <typename GrantTypeT = Aws::String>
+  void SetGrantType(GrantTypeT&& value) {
+    m_grantTypeHasBeenSet = true;
+    m_grantType = std::forward<GrantTypeT>(value);
+  }
+  template <typename GrantTypeT = Aws::String>
+  CreateOAuth2TokenWithIAMRequest& WithGrantType(GrantTypeT&& value) {
+    SetGrantType(std::forward<GrantTypeT>(value));
+    return *this;
+  }
+  ///@}
+
+  ///@{
+  /**
+   * <p>The OAuth resource for which the access token is requested. Example:
+   * &quot;aws-mcp.amazonaws.com&quot;.</p>
+   */
+  inline const Aws::String& GetResource() const { return m_resource; }
+  inline bool ResourceHasBeenSet() const { return m_resourceHasBeenSet; }
+  template <typename ResourceT = Aws::String>
+  void SetResource(ResourceT&& value) {
+    m_resourceHasBeenSet = true;
+    m_resource = std::forward<ResourceT>(value);
+  }
+  template <typename ResourceT = Aws::String>
+  CreateOAuth2TokenWithIAMRequest& WithResource(ResourceT&& value) {
+    SetResource(std::forward<ResourceT>(value));
+    return *this;
+  }
+  ///@}
+ private:
+  Aws::String m_grantType;
+
+  Aws::String m_resource;
+  bool m_grantTypeHasBeenSet = false;
+  bool m_resourceHasBeenSet = false;
+};
+
+}  // namespace Model
+}  // namespace Signin
+}  // namespace Aws