SSOAdminClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/sso-admin/SSOAdminPaginationBase.h>
#include <aws/sso-admin/SSOAdminServiceClientModel.h>
#include <aws/sso-admin/SSOAdminWaiter.h>
#include <aws/sso-admin/SSOAdmin_EXPORTS.h>
 
namespace Aws {
namespace SSOAdmin {
class AWS_SSOADMIN_API SSOAdminClient : public Aws::Client::AWSJsonClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<SSOAdminClient>,
                                        public SSOAdminPaginationBase<SSOAdminClient>,
                                        public SSOAdminWaiter<SSOAdminClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef SSOAdminClientConfiguration ClientConfigurationType;
  typedef SSOAdminEndpointProvider EndpointProviderType;
 
  SSOAdminClient(const Aws::SSOAdmin::SSOAdminClientConfiguration& clientConfiguration = Aws::SSOAdmin::SSOAdminClientConfiguration(),
                 std::shared_ptr<SSOAdminEndpointProviderBase> endpointProvider = nullptr);
 
  SSOAdminClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<SSOAdminEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::SSOAdmin::SSOAdminClientConfiguration& clientConfiguration = Aws::SSOAdmin::SSOAdminClientConfiguration());
 
  SSOAdminClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 std::shared_ptr<SSOAdminEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::SSOAdmin::SSOAdminClientConfiguration& clientConfiguration = Aws::SSOAdmin::SSOAdminClientConfiguration());
 
  /* Legacy constructors due deprecation */
  SSOAdminClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SSOAdminClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SSOAdminClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~SSOAdminClient();
 
  virtual Model::AddRegionOutcome AddRegion(const Model::AddRegionRequest& request) const;
 
  template <typename AddRegionRequestT = Model::AddRegionRequest>
  Model::AddRegionOutcomeCallable AddRegionCallable(const AddRegionRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::AddRegion, request);
  }
 
  template <typename AddRegionRequestT = Model::AddRegionRequest>
  void AddRegionAsync(const AddRegionRequestT& request, const AddRegionResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::AddRegion, request, handler, context);
  }
 
  virtual Model::AttachCustomerManagedPolicyReferenceToPermissionSetOutcome AttachCustomerManagedPolicyReferenceToPermissionSet(
      const Model::AttachCustomerManagedPolicyReferenceToPermissionSetRequest& request) const;
 
  template <typename AttachCustomerManagedPolicyReferenceToPermissionSetRequestT =
                Model::AttachCustomerManagedPolicyReferenceToPermissionSetRequest>
  Model::AttachCustomerManagedPolicyReferenceToPermissionSetOutcomeCallable AttachCustomerManagedPolicyReferenceToPermissionSetCallable(
      const AttachCustomerManagedPolicyReferenceToPermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::AttachCustomerManagedPolicyReferenceToPermissionSet, request);
  }
 
  template <typename AttachCustomerManagedPolicyReferenceToPermissionSetRequestT =
                Model::AttachCustomerManagedPolicyReferenceToPermissionSetRequest>
  void AttachCustomerManagedPolicyReferenceToPermissionSetAsync(
      const AttachCustomerManagedPolicyReferenceToPermissionSetRequestT& request,
      const AttachCustomerManagedPolicyReferenceToPermissionSetResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::AttachCustomerManagedPolicyReferenceToPermissionSet, request, handler, context);
  }
 
  virtual Model::AttachManagedPolicyToPermissionSetOutcome AttachManagedPolicyToPermissionSet(
      const Model::AttachManagedPolicyToPermissionSetRequest& request) const;
 
  template <typename AttachManagedPolicyToPermissionSetRequestT = Model::AttachManagedPolicyToPermissionSetRequest>
  Model::AttachManagedPolicyToPermissionSetOutcomeCallable AttachManagedPolicyToPermissionSetCallable(
      const AttachManagedPolicyToPermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::AttachManagedPolicyToPermissionSet, request);
  }
 
  template <typename AttachManagedPolicyToPermissionSetRequestT = Model::AttachManagedPolicyToPermissionSetRequest>
  void AttachManagedPolicyToPermissionSetAsync(const AttachManagedPolicyToPermissionSetRequestT& request,
                                               const AttachManagedPolicyToPermissionSetResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::AttachManagedPolicyToPermissionSet, request, handler, context);
  }
 
  virtual Model::CreateAccountAssignmentOutcome CreateAccountAssignment(const Model::CreateAccountAssignmentRequest& request) const;
 
  template <typename CreateAccountAssignmentRequestT = Model::CreateAccountAssignmentRequest>
  Model::CreateAccountAssignmentOutcomeCallable CreateAccountAssignmentCallable(const CreateAccountAssignmentRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::CreateAccountAssignment, request);
  }
 
  template <typename CreateAccountAssignmentRequestT = Model::CreateAccountAssignmentRequest>
  void CreateAccountAssignmentAsync(const CreateAccountAssignmentRequestT& request,
                                    const CreateAccountAssignmentResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::CreateAccountAssignment, request, handler, context);
  }
 
  virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const;
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::CreateApplication, request);
  }
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  void CreateApplicationAsync(const CreateApplicationRequestT& request, const CreateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::CreateApplication, request, handler, context);
  }
 
  virtual Model::CreateApplicationAssignmentOutcome CreateApplicationAssignment(
      const Model::CreateApplicationAssignmentRequest& request) const;
 
  template <typename CreateApplicationAssignmentRequestT = Model::CreateApplicationAssignmentRequest>
  Model::CreateApplicationAssignmentOutcomeCallable CreateApplicationAssignmentCallable(
      const CreateApplicationAssignmentRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::CreateApplicationAssignment, request);
  }
 
  template <typename CreateApplicationAssignmentRequestT = Model::CreateApplicationAssignmentRequest>
  void CreateApplicationAssignmentAsync(const CreateApplicationAssignmentRequestT& request,
                                        const CreateApplicationAssignmentResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::CreateApplicationAssignment, request, handler, context);
  }
 
  virtual Model::CreateInstanceOutcome CreateInstance(const Model::CreateInstanceRequest& request = {}) const;
 
  template <typename CreateInstanceRequestT = Model::CreateInstanceRequest>
  Model::CreateInstanceOutcomeCallable CreateInstanceCallable(const CreateInstanceRequestT& request = {}) const {
    return SubmitCallable(&SSOAdminClient::CreateInstance, request);
  }
 
  template <typename CreateInstanceRequestT = Model::CreateInstanceRequest>
  void CreateInstanceAsync(const CreateInstanceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const CreateInstanceRequestT& request = {}) const {
    return SubmitAsync(&SSOAdminClient::CreateInstance, request, handler, context);
  }
 
  virtual Model::CreateInstanceAccessControlAttributeConfigurationOutcome CreateInstanceAccessControlAttributeConfiguration(
      const Model::CreateInstanceAccessControlAttributeConfigurationRequest& request) const;
 
  template <
      typename CreateInstanceAccessControlAttributeConfigurationRequestT = Model::CreateInstanceAccessControlAttributeConfigurationRequest>
  Model::CreateInstanceAccessControlAttributeConfigurationOutcomeCallable CreateInstanceAccessControlAttributeConfigurationCallable(
      const CreateInstanceAccessControlAttributeConfigurationRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::CreateInstanceAccessControlAttributeConfiguration, request);
  }
 
  template <
      typename CreateInstanceAccessControlAttributeConfigurationRequestT = Model::CreateInstanceAccessControlAttributeConfigurationRequest>
  void CreateInstanceAccessControlAttributeConfigurationAsync(
      const CreateInstanceAccessControlAttributeConfigurationRequestT& request,
      const CreateInstanceAccessControlAttributeConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::CreateInstanceAccessControlAttributeConfiguration, request, handler, context);
  }
 
  virtual Model::CreatePermissionSetOutcome CreatePermissionSet(const Model::CreatePermissionSetRequest& request) const;
 
  template <typename CreatePermissionSetRequestT = Model::CreatePermissionSetRequest>
  Model::CreatePermissionSetOutcomeCallable CreatePermissionSetCallable(const CreatePermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::CreatePermissionSet, request);
  }
 
  template <typename CreatePermissionSetRequestT = Model::CreatePermissionSetRequest>
  void CreatePermissionSetAsync(const CreatePermissionSetRequestT& request, const CreatePermissionSetResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::CreatePermissionSet, request, handler, context);
  }
 
  virtual Model::CreateTrustedTokenIssuerOutcome CreateTrustedTokenIssuer(const Model::CreateTrustedTokenIssuerRequest& request) const;
 
  template <typename CreateTrustedTokenIssuerRequestT = Model::CreateTrustedTokenIssuerRequest>
  Model::CreateTrustedTokenIssuerOutcomeCallable CreateTrustedTokenIssuerCallable(const CreateTrustedTokenIssuerRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::CreateTrustedTokenIssuer, request);
  }
 
  template <typename CreateTrustedTokenIssuerRequestT = Model::CreateTrustedTokenIssuerRequest>
  void CreateTrustedTokenIssuerAsync(const CreateTrustedTokenIssuerRequestT& request,
                                     const CreateTrustedTokenIssuerResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::CreateTrustedTokenIssuer, request, handler, context);
  }
 
  virtual Model::DeleteAccountAssignmentOutcome DeleteAccountAssignment(const Model::DeleteAccountAssignmentRequest& request) const;
 
  template <typename DeleteAccountAssignmentRequestT = Model::DeleteAccountAssignmentRequest>
  Model::DeleteAccountAssignmentOutcomeCallable DeleteAccountAssignmentCallable(const DeleteAccountAssignmentRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DeleteAccountAssignment, request);
  }
 
  template <typename DeleteAccountAssignmentRequestT = Model::DeleteAccountAssignmentRequest>
  void DeleteAccountAssignmentAsync(const DeleteAccountAssignmentRequestT& request,
                                    const DeleteAccountAssignmentResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DeleteAccountAssignment, request, handler, context);
  }
 
  virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DeleteApplication, request);
  }
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DeleteApplication, request, handler, context);
  }
 
  virtual Model::DeleteApplicationAccessScopeOutcome DeleteApplicationAccessScope(
      const Model::DeleteApplicationAccessScopeRequest& request) const;
 
  template <typename DeleteApplicationAccessScopeRequestT = Model::DeleteApplicationAccessScopeRequest>
  Model::DeleteApplicationAccessScopeOutcomeCallable DeleteApplicationAccessScopeCallable(
      const DeleteApplicationAccessScopeRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DeleteApplicationAccessScope, request);
  }
 
  template <typename DeleteApplicationAccessScopeRequestT = Model::DeleteApplicationAccessScopeRequest>
  void DeleteApplicationAccessScopeAsync(const DeleteApplicationAccessScopeRequestT& request,
                                         const DeleteApplicationAccessScopeResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DeleteApplicationAccessScope, request, handler, context);
  }
 
  virtual Model::DeleteApplicationAssignmentOutcome DeleteApplicationAssignment(
      const Model::DeleteApplicationAssignmentRequest& request) const;
 
  template <typename DeleteApplicationAssignmentRequestT = Model::DeleteApplicationAssignmentRequest>
  Model::DeleteApplicationAssignmentOutcomeCallable DeleteApplicationAssignmentCallable(
      const DeleteApplicationAssignmentRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DeleteApplicationAssignment, request);
  }
 
  template <typename DeleteApplicationAssignmentRequestT = Model::DeleteApplicationAssignmentRequest>
  void DeleteApplicationAssignmentAsync(const DeleteApplicationAssignmentRequestT& request,
                                        const DeleteApplicationAssignmentResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DeleteApplicationAssignment, request, handler, context);
  }
 
  virtual Model::DeleteApplicationAuthenticationMethodOutcome DeleteApplicationAuthenticationMethod(
      const Model::DeleteApplicationAuthenticationMethodRequest& request) const;
 
  template <typename DeleteApplicationAuthenticationMethodRequestT = Model::DeleteApplicationAuthenticationMethodRequest>
  Model::DeleteApplicationAuthenticationMethodOutcomeCallable DeleteApplicationAuthenticationMethodCallable(
      const DeleteApplicationAuthenticationMethodRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DeleteApplicationAuthenticationMethod, request);
  }
 
  template <typename DeleteApplicationAuthenticationMethodRequestT = Model::DeleteApplicationAuthenticationMethodRequest>
  void DeleteApplicationAuthenticationMethodAsync(const DeleteApplicationAuthenticationMethodRequestT& request,
                                                  const DeleteApplicationAuthenticationMethodResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DeleteApplicationAuthenticationMethod, request, handler, context);
  }
 
  virtual Model::DeleteApplicationGrantOutcome DeleteApplicationGrant(const Model::DeleteApplicationGrantRequest& request) const;
 
  template <typename DeleteApplicationGrantRequestT = Model::DeleteApplicationGrantRequest>
  Model::DeleteApplicationGrantOutcomeCallable DeleteApplicationGrantCallable(const DeleteApplicationGrantRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DeleteApplicationGrant, request);
  }
 
  template <typename DeleteApplicationGrantRequestT = Model::DeleteApplicationGrantRequest>
  void DeleteApplicationGrantAsync(const DeleteApplicationGrantRequestT& request,
                                   const DeleteApplicationGrantResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DeleteApplicationGrant, request, handler, context);
  }
 
  virtual Model::DeleteInlinePolicyFromPermissionSetOutcome DeleteInlinePolicyFromPermissionSet(
      const Model::DeleteInlinePolicyFromPermissionSetRequest& request) const;
 
  template <typename DeleteInlinePolicyFromPermissionSetRequestT = Model::DeleteInlinePolicyFromPermissionSetRequest>
  Model::DeleteInlinePolicyFromPermissionSetOutcomeCallable DeleteInlinePolicyFromPermissionSetCallable(
      const DeleteInlinePolicyFromPermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DeleteInlinePolicyFromPermissionSet, request);
  }
 
  template <typename DeleteInlinePolicyFromPermissionSetRequestT = Model::DeleteInlinePolicyFromPermissionSetRequest>
  void DeleteInlinePolicyFromPermissionSetAsync(const DeleteInlinePolicyFromPermissionSetRequestT& request,
                                                const DeleteInlinePolicyFromPermissionSetResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DeleteInlinePolicyFromPermissionSet, request, handler, context);
  }
 
  virtual Model::DeleteInstanceOutcome DeleteInstance(const Model::DeleteInstanceRequest& request) const;
 
  template <typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
  Model::DeleteInstanceOutcomeCallable DeleteInstanceCallable(const DeleteInstanceRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DeleteInstance, request);
  }
 
  template <typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
  void DeleteInstanceAsync(const DeleteInstanceRequestT& request, const DeleteInstanceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DeleteInstance, request, handler, context);
  }
 
  virtual Model::DeleteInstanceAccessControlAttributeConfigurationOutcome DeleteInstanceAccessControlAttributeConfiguration(
      const Model::DeleteInstanceAccessControlAttributeConfigurationRequest& request) const;
 
  template <
      typename DeleteInstanceAccessControlAttributeConfigurationRequestT = Model::DeleteInstanceAccessControlAttributeConfigurationRequest>
  Model::DeleteInstanceAccessControlAttributeConfigurationOutcomeCallable DeleteInstanceAccessControlAttributeConfigurationCallable(
      const DeleteInstanceAccessControlAttributeConfigurationRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DeleteInstanceAccessControlAttributeConfiguration, request);
  }
 
  template <
      typename DeleteInstanceAccessControlAttributeConfigurationRequestT = Model::DeleteInstanceAccessControlAttributeConfigurationRequest>
  void DeleteInstanceAccessControlAttributeConfigurationAsync(
      const DeleteInstanceAccessControlAttributeConfigurationRequestT& request,
      const DeleteInstanceAccessControlAttributeConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DeleteInstanceAccessControlAttributeConfiguration, request, handler, context);
  }
 
  virtual Model::DeletePermissionSetOutcome DeletePermissionSet(const Model::DeletePermissionSetRequest& request) const;
 
  template <typename DeletePermissionSetRequestT = Model::DeletePermissionSetRequest>
  Model::DeletePermissionSetOutcomeCallable DeletePermissionSetCallable(const DeletePermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DeletePermissionSet, request);
  }
 
  template <typename DeletePermissionSetRequestT = Model::DeletePermissionSetRequest>
  void DeletePermissionSetAsync(const DeletePermissionSetRequestT& request, const DeletePermissionSetResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DeletePermissionSet, request, handler, context);
  }
 
  virtual Model::DeletePermissionsBoundaryFromPermissionSetOutcome DeletePermissionsBoundaryFromPermissionSet(
      const Model::DeletePermissionsBoundaryFromPermissionSetRequest& request) const;
 
  template <typename DeletePermissionsBoundaryFromPermissionSetRequestT = Model::DeletePermissionsBoundaryFromPermissionSetRequest>
  Model::DeletePermissionsBoundaryFromPermissionSetOutcomeCallable DeletePermissionsBoundaryFromPermissionSetCallable(
      const DeletePermissionsBoundaryFromPermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DeletePermissionsBoundaryFromPermissionSet, request);
  }
 
  template <typename DeletePermissionsBoundaryFromPermissionSetRequestT = Model::DeletePermissionsBoundaryFromPermissionSetRequest>
  void DeletePermissionsBoundaryFromPermissionSetAsync(
      const DeletePermissionsBoundaryFromPermissionSetRequestT& request,
      const DeletePermissionsBoundaryFromPermissionSetResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DeletePermissionsBoundaryFromPermissionSet, request, handler, context);
  }
 
  virtual Model::DeleteTrustedTokenIssuerOutcome DeleteTrustedTokenIssuer(const Model::DeleteTrustedTokenIssuerRequest& request) const;
 
  template <typename DeleteTrustedTokenIssuerRequestT = Model::DeleteTrustedTokenIssuerRequest>
  Model::DeleteTrustedTokenIssuerOutcomeCallable DeleteTrustedTokenIssuerCallable(const DeleteTrustedTokenIssuerRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DeleteTrustedTokenIssuer, request);
  }
 
  template <typename DeleteTrustedTokenIssuerRequestT = Model::DeleteTrustedTokenIssuerRequest>
  void DeleteTrustedTokenIssuerAsync(const DeleteTrustedTokenIssuerRequestT& request,
                                     const DeleteTrustedTokenIssuerResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DeleteTrustedTokenIssuer, request, handler, context);
  }
 
  virtual Model::DescribeAccountAssignmentCreationStatusOutcome DescribeAccountAssignmentCreationStatus(
      const Model::DescribeAccountAssignmentCreationStatusRequest& request) const;
 
  template <typename DescribeAccountAssignmentCreationStatusRequestT = Model::DescribeAccountAssignmentCreationStatusRequest>
  Model::DescribeAccountAssignmentCreationStatusOutcomeCallable DescribeAccountAssignmentCreationStatusCallable(
      const DescribeAccountAssignmentCreationStatusRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DescribeAccountAssignmentCreationStatus, request);
  }
 
  template <typename DescribeAccountAssignmentCreationStatusRequestT = Model::DescribeAccountAssignmentCreationStatusRequest>
  void DescribeAccountAssignmentCreationStatusAsync(const DescribeAccountAssignmentCreationStatusRequestT& request,
                                                    const DescribeAccountAssignmentCreationStatusResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DescribeAccountAssignmentCreationStatus, request, handler, context);
  }
 
  virtual Model::DescribeAccountAssignmentDeletionStatusOutcome DescribeAccountAssignmentDeletionStatus(
      const Model::DescribeAccountAssignmentDeletionStatusRequest& request) const;
 
  template <typename DescribeAccountAssignmentDeletionStatusRequestT = Model::DescribeAccountAssignmentDeletionStatusRequest>
  Model::DescribeAccountAssignmentDeletionStatusOutcomeCallable DescribeAccountAssignmentDeletionStatusCallable(
      const DescribeAccountAssignmentDeletionStatusRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DescribeAccountAssignmentDeletionStatus, request);
  }
 
  template <typename DescribeAccountAssignmentDeletionStatusRequestT = Model::DescribeAccountAssignmentDeletionStatusRequest>
  void DescribeAccountAssignmentDeletionStatusAsync(const DescribeAccountAssignmentDeletionStatusRequestT& request,
                                                    const DescribeAccountAssignmentDeletionStatusResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DescribeAccountAssignmentDeletionStatus, request, handler, context);
  }
 
  virtual Model::DescribeApplicationOutcome DescribeApplication(const Model::DescribeApplicationRequest& request) const;
 
  template <typename DescribeApplicationRequestT = Model::DescribeApplicationRequest>
  Model::DescribeApplicationOutcomeCallable DescribeApplicationCallable(const DescribeApplicationRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DescribeApplication, request);
  }
 
  template <typename DescribeApplicationRequestT = Model::DescribeApplicationRequest>
  void DescribeApplicationAsync(const DescribeApplicationRequestT& request, const DescribeApplicationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DescribeApplication, request, handler, context);
  }
 
  virtual Model::DescribeApplicationAssignmentOutcome DescribeApplicationAssignment(
      const Model::DescribeApplicationAssignmentRequest& request) const;
 
  template <typename DescribeApplicationAssignmentRequestT = Model::DescribeApplicationAssignmentRequest>
  Model::DescribeApplicationAssignmentOutcomeCallable DescribeApplicationAssignmentCallable(
      const DescribeApplicationAssignmentRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DescribeApplicationAssignment, request);
  }
 
  template <typename DescribeApplicationAssignmentRequestT = Model::DescribeApplicationAssignmentRequest>
  void DescribeApplicationAssignmentAsync(const DescribeApplicationAssignmentRequestT& request,
                                          const DescribeApplicationAssignmentResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DescribeApplicationAssignment, request, handler, context);
  }
 
  virtual Model::DescribeApplicationProviderOutcome DescribeApplicationProvider(
      const Model::DescribeApplicationProviderRequest& request) const;
 
  template <typename DescribeApplicationProviderRequestT = Model::DescribeApplicationProviderRequest>
  Model::DescribeApplicationProviderOutcomeCallable DescribeApplicationProviderCallable(
      const DescribeApplicationProviderRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DescribeApplicationProvider, request);
  }
 
  template <typename DescribeApplicationProviderRequestT = Model::DescribeApplicationProviderRequest>
  void DescribeApplicationProviderAsync(const DescribeApplicationProviderRequestT& request,
                                        const DescribeApplicationProviderResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DescribeApplicationProvider, request, handler, context);
  }
 
  virtual Model::DescribeInstanceOutcome DescribeInstance(const Model::DescribeInstanceRequest& request) const;
 
  template <typename DescribeInstanceRequestT = Model::DescribeInstanceRequest>
  Model::DescribeInstanceOutcomeCallable DescribeInstanceCallable(const DescribeInstanceRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DescribeInstance, request);
  }
 
  template <typename DescribeInstanceRequestT = Model::DescribeInstanceRequest>
  void DescribeInstanceAsync(const DescribeInstanceRequestT& request, const DescribeInstanceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DescribeInstance, request, handler, context);
  }
 
  virtual Model::DescribeInstanceAccessControlAttributeConfigurationOutcome DescribeInstanceAccessControlAttributeConfiguration(
      const Model::DescribeInstanceAccessControlAttributeConfigurationRequest& request) const;
 
  template <typename DescribeInstanceAccessControlAttributeConfigurationRequestT =
                Model::DescribeInstanceAccessControlAttributeConfigurationRequest>
  Model::DescribeInstanceAccessControlAttributeConfigurationOutcomeCallable DescribeInstanceAccessControlAttributeConfigurationCallable(
      const DescribeInstanceAccessControlAttributeConfigurationRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DescribeInstanceAccessControlAttributeConfiguration, request);
  }
 
  template <typename DescribeInstanceAccessControlAttributeConfigurationRequestT =
                Model::DescribeInstanceAccessControlAttributeConfigurationRequest>
  void DescribeInstanceAccessControlAttributeConfigurationAsync(
      const DescribeInstanceAccessControlAttributeConfigurationRequestT& request,
      const DescribeInstanceAccessControlAttributeConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DescribeInstanceAccessControlAttributeConfiguration, request, handler, context);
  }
 
  virtual Model::DescribePermissionSetOutcome DescribePermissionSet(const Model::DescribePermissionSetRequest& request) const;
 
  template <typename DescribePermissionSetRequestT = Model::DescribePermissionSetRequest>
  Model::DescribePermissionSetOutcomeCallable DescribePermissionSetCallable(const DescribePermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DescribePermissionSet, request);
  }
 
  template <typename DescribePermissionSetRequestT = Model::DescribePermissionSetRequest>
  void DescribePermissionSetAsync(const DescribePermissionSetRequestT& request, const DescribePermissionSetResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DescribePermissionSet, request, handler, context);
  }
 
  virtual Model::DescribePermissionSetProvisioningStatusOutcome DescribePermissionSetProvisioningStatus(
      const Model::DescribePermissionSetProvisioningStatusRequest& request) const;
 
  template <typename DescribePermissionSetProvisioningStatusRequestT = Model::DescribePermissionSetProvisioningStatusRequest>
  Model::DescribePermissionSetProvisioningStatusOutcomeCallable DescribePermissionSetProvisioningStatusCallable(
      const DescribePermissionSetProvisioningStatusRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DescribePermissionSetProvisioningStatus, request);
  }
 
  template <typename DescribePermissionSetProvisioningStatusRequestT = Model::DescribePermissionSetProvisioningStatusRequest>
  void DescribePermissionSetProvisioningStatusAsync(const DescribePermissionSetProvisioningStatusRequestT& request,
                                                    const DescribePermissionSetProvisioningStatusResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DescribePermissionSetProvisioningStatus, request, handler, context);
  }
 
  virtual Model::DescribeRegionOutcome DescribeRegion(const Model::DescribeRegionRequest& request) const;
 
  template <typename DescribeRegionRequestT = Model::DescribeRegionRequest>
  Model::DescribeRegionOutcomeCallable DescribeRegionCallable(const DescribeRegionRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DescribeRegion, request);
  }
 
  template <typename DescribeRegionRequestT = Model::DescribeRegionRequest>
  void DescribeRegionAsync(const DescribeRegionRequestT& request, const DescribeRegionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DescribeRegion, request, handler, context);
  }
 
  virtual Model::DescribeTrustedTokenIssuerOutcome DescribeTrustedTokenIssuer(
      const Model::DescribeTrustedTokenIssuerRequest& request) const;
 
  template <typename DescribeTrustedTokenIssuerRequestT = Model::DescribeTrustedTokenIssuerRequest>
  Model::DescribeTrustedTokenIssuerOutcomeCallable DescribeTrustedTokenIssuerCallable(
      const DescribeTrustedTokenIssuerRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DescribeTrustedTokenIssuer, request);
  }
 
  template <typename DescribeTrustedTokenIssuerRequestT = Model::DescribeTrustedTokenIssuerRequest>
  void DescribeTrustedTokenIssuerAsync(const DescribeTrustedTokenIssuerRequestT& request,
                                       const DescribeTrustedTokenIssuerResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DescribeTrustedTokenIssuer, request, handler, context);
  }
 
  virtual Model::DetachCustomerManagedPolicyReferenceFromPermissionSetOutcome DetachCustomerManagedPolicyReferenceFromPermissionSet(
      const Model::DetachCustomerManagedPolicyReferenceFromPermissionSetRequest& request) const;
 
  template <typename DetachCustomerManagedPolicyReferenceFromPermissionSetRequestT =
                Model::DetachCustomerManagedPolicyReferenceFromPermissionSetRequest>
  Model::DetachCustomerManagedPolicyReferenceFromPermissionSetOutcomeCallable DetachCustomerManagedPolicyReferenceFromPermissionSetCallable(
      const DetachCustomerManagedPolicyReferenceFromPermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DetachCustomerManagedPolicyReferenceFromPermissionSet, request);
  }
 
  template <typename DetachCustomerManagedPolicyReferenceFromPermissionSetRequestT =
                Model::DetachCustomerManagedPolicyReferenceFromPermissionSetRequest>
  void DetachCustomerManagedPolicyReferenceFromPermissionSetAsync(
      const DetachCustomerManagedPolicyReferenceFromPermissionSetRequestT& request,
      const DetachCustomerManagedPolicyReferenceFromPermissionSetResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DetachCustomerManagedPolicyReferenceFromPermissionSet, request, handler, context);
  }
 
  virtual Model::DetachManagedPolicyFromPermissionSetOutcome DetachManagedPolicyFromPermissionSet(
      const Model::DetachManagedPolicyFromPermissionSetRequest& request) const;
 
  template <typename DetachManagedPolicyFromPermissionSetRequestT = Model::DetachManagedPolicyFromPermissionSetRequest>
  Model::DetachManagedPolicyFromPermissionSetOutcomeCallable DetachManagedPolicyFromPermissionSetCallable(
      const DetachManagedPolicyFromPermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::DetachManagedPolicyFromPermissionSet, request);
  }
 
  template <typename DetachManagedPolicyFromPermissionSetRequestT = Model::DetachManagedPolicyFromPermissionSetRequest>
  void DetachManagedPolicyFromPermissionSetAsync(const DetachManagedPolicyFromPermissionSetRequestT& request,
                                                 const DetachManagedPolicyFromPermissionSetResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::DetachManagedPolicyFromPermissionSet, request, handler, context);
  }
 
  virtual Model::GetApplicationAccessScopeOutcome GetApplicationAccessScope(const Model::GetApplicationAccessScopeRequest& request) const;
 
  template <typename GetApplicationAccessScopeRequestT = Model::GetApplicationAccessScopeRequest>
  Model::GetApplicationAccessScopeOutcomeCallable GetApplicationAccessScopeCallable(
      const GetApplicationAccessScopeRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::GetApplicationAccessScope, request);
  }
 
  template <typename GetApplicationAccessScopeRequestT = Model::GetApplicationAccessScopeRequest>
  void GetApplicationAccessScopeAsync(const GetApplicationAccessScopeRequestT& request,
                                      const GetApplicationAccessScopeResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::GetApplicationAccessScope, request, handler, context);
  }
 
  virtual Model::GetApplicationAssignmentConfigurationOutcome GetApplicationAssignmentConfiguration(
      const Model::GetApplicationAssignmentConfigurationRequest& request) const;
 
  template <typename GetApplicationAssignmentConfigurationRequestT = Model::GetApplicationAssignmentConfigurationRequest>
  Model::GetApplicationAssignmentConfigurationOutcomeCallable GetApplicationAssignmentConfigurationCallable(
      const GetApplicationAssignmentConfigurationRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::GetApplicationAssignmentConfiguration, request);
  }
 
  template <typename GetApplicationAssignmentConfigurationRequestT = Model::GetApplicationAssignmentConfigurationRequest>
  void GetApplicationAssignmentConfigurationAsync(const GetApplicationAssignmentConfigurationRequestT& request,
                                                  const GetApplicationAssignmentConfigurationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::GetApplicationAssignmentConfiguration, request, handler, context);
  }
 
  virtual Model::GetApplicationAuthenticationMethodOutcome GetApplicationAuthenticationMethod(
      const Model::GetApplicationAuthenticationMethodRequest& request) const;
 
  template <typename GetApplicationAuthenticationMethodRequestT = Model::GetApplicationAuthenticationMethodRequest>
  Model::GetApplicationAuthenticationMethodOutcomeCallable GetApplicationAuthenticationMethodCallable(
      const GetApplicationAuthenticationMethodRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::GetApplicationAuthenticationMethod, request);
  }
 
  template <typename GetApplicationAuthenticationMethodRequestT = Model::GetApplicationAuthenticationMethodRequest>
  void GetApplicationAuthenticationMethodAsync(const GetApplicationAuthenticationMethodRequestT& request,
                                               const GetApplicationAuthenticationMethodResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::GetApplicationAuthenticationMethod, request, handler, context);
  }
 
  virtual Model::GetApplicationGrantOutcome GetApplicationGrant(const Model::GetApplicationGrantRequest& request) const;
 
  template <typename GetApplicationGrantRequestT = Model::GetApplicationGrantRequest>
  Model::GetApplicationGrantOutcomeCallable GetApplicationGrantCallable(const GetApplicationGrantRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::GetApplicationGrant, request);
  }
 
  template <typename GetApplicationGrantRequestT = Model::GetApplicationGrantRequest>
  void GetApplicationGrantAsync(const GetApplicationGrantRequestT& request, const GetApplicationGrantResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::GetApplicationGrant, request, handler, context);
  }
 
  virtual Model::GetApplicationSessionConfigurationOutcome GetApplicationSessionConfiguration(
      const Model::GetApplicationSessionConfigurationRequest& request) const;
 
  template <typename GetApplicationSessionConfigurationRequestT = Model::GetApplicationSessionConfigurationRequest>
  Model::GetApplicationSessionConfigurationOutcomeCallable GetApplicationSessionConfigurationCallable(
      const GetApplicationSessionConfigurationRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::GetApplicationSessionConfiguration, request);
  }
 
  template <typename GetApplicationSessionConfigurationRequestT = Model::GetApplicationSessionConfigurationRequest>
  void GetApplicationSessionConfigurationAsync(const GetApplicationSessionConfigurationRequestT& request,
                                               const GetApplicationSessionConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::GetApplicationSessionConfiguration, request, handler, context);
  }
 
  virtual Model::GetInlinePolicyForPermissionSetOutcome GetInlinePolicyForPermissionSet(
      const Model::GetInlinePolicyForPermissionSetRequest& request) const;
 
  template <typename GetInlinePolicyForPermissionSetRequestT = Model::GetInlinePolicyForPermissionSetRequest>
  Model::GetInlinePolicyForPermissionSetOutcomeCallable GetInlinePolicyForPermissionSetCallable(
      const GetInlinePolicyForPermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::GetInlinePolicyForPermissionSet, request);
  }
 
  template <typename GetInlinePolicyForPermissionSetRequestT = Model::GetInlinePolicyForPermissionSetRequest>
  void GetInlinePolicyForPermissionSetAsync(const GetInlinePolicyForPermissionSetRequestT& request,
                                            const GetInlinePolicyForPermissionSetResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::GetInlinePolicyForPermissionSet, request, handler, context);
  }
 
  virtual Model::GetPermissionsBoundaryForPermissionSetOutcome GetPermissionsBoundaryForPermissionSet(
      const Model::GetPermissionsBoundaryForPermissionSetRequest& request) const;
 
  template <typename GetPermissionsBoundaryForPermissionSetRequestT = Model::GetPermissionsBoundaryForPermissionSetRequest>
  Model::GetPermissionsBoundaryForPermissionSetOutcomeCallable GetPermissionsBoundaryForPermissionSetCallable(
      const GetPermissionsBoundaryForPermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::GetPermissionsBoundaryForPermissionSet, request);
  }
 
  template <typename GetPermissionsBoundaryForPermissionSetRequestT = Model::GetPermissionsBoundaryForPermissionSetRequest>
  void GetPermissionsBoundaryForPermissionSetAsync(const GetPermissionsBoundaryForPermissionSetRequestT& request,
                                                   const GetPermissionsBoundaryForPermissionSetResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::GetPermissionsBoundaryForPermissionSet, request, handler, context);
  }
 
  virtual Model::ListAccountAssignmentCreationStatusOutcome ListAccountAssignmentCreationStatus(
      const Model::ListAccountAssignmentCreationStatusRequest& request) const;
 
  template <typename ListAccountAssignmentCreationStatusRequestT = Model::ListAccountAssignmentCreationStatusRequest>
  Model::ListAccountAssignmentCreationStatusOutcomeCallable ListAccountAssignmentCreationStatusCallable(
      const ListAccountAssignmentCreationStatusRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListAccountAssignmentCreationStatus, request);
  }
 
  template <typename ListAccountAssignmentCreationStatusRequestT = Model::ListAccountAssignmentCreationStatusRequest>
  void ListAccountAssignmentCreationStatusAsync(const ListAccountAssignmentCreationStatusRequestT& request,
                                                const ListAccountAssignmentCreationStatusResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListAccountAssignmentCreationStatus, request, handler, context);
  }
 
  virtual Model::ListAccountAssignmentDeletionStatusOutcome ListAccountAssignmentDeletionStatus(
      const Model::ListAccountAssignmentDeletionStatusRequest& request) const;
 
  template <typename ListAccountAssignmentDeletionStatusRequestT = Model::ListAccountAssignmentDeletionStatusRequest>
  Model::ListAccountAssignmentDeletionStatusOutcomeCallable ListAccountAssignmentDeletionStatusCallable(
      const ListAccountAssignmentDeletionStatusRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListAccountAssignmentDeletionStatus, request);
  }
 
  template <typename ListAccountAssignmentDeletionStatusRequestT = Model::ListAccountAssignmentDeletionStatusRequest>
  void ListAccountAssignmentDeletionStatusAsync(const ListAccountAssignmentDeletionStatusRequestT& request,
                                                const ListAccountAssignmentDeletionStatusResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListAccountAssignmentDeletionStatus, request, handler, context);
  }
 
  virtual Model::ListAccountAssignmentsOutcome ListAccountAssignments(const Model::ListAccountAssignmentsRequest& request) const;
 
  template <typename ListAccountAssignmentsRequestT = Model::ListAccountAssignmentsRequest>
  Model::ListAccountAssignmentsOutcomeCallable ListAccountAssignmentsCallable(const ListAccountAssignmentsRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListAccountAssignments, request);
  }
 
  template <typename ListAccountAssignmentsRequestT = Model::ListAccountAssignmentsRequest>
  void ListAccountAssignmentsAsync(const ListAccountAssignmentsRequestT& request,
                                   const ListAccountAssignmentsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListAccountAssignments, request, handler, context);
  }
 
  virtual Model::ListAccountAssignmentsForPrincipalOutcome ListAccountAssignmentsForPrincipal(
      const Model::ListAccountAssignmentsForPrincipalRequest& request) const;
 
  template <typename ListAccountAssignmentsForPrincipalRequestT = Model::ListAccountAssignmentsForPrincipalRequest>
  Model::ListAccountAssignmentsForPrincipalOutcomeCallable ListAccountAssignmentsForPrincipalCallable(
      const ListAccountAssignmentsForPrincipalRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListAccountAssignmentsForPrincipal, request);
  }
 
  template <typename ListAccountAssignmentsForPrincipalRequestT = Model::ListAccountAssignmentsForPrincipalRequest>
  void ListAccountAssignmentsForPrincipalAsync(const ListAccountAssignmentsForPrincipalRequestT& request,
                                               const ListAccountAssignmentsForPrincipalResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListAccountAssignmentsForPrincipal, request, handler, context);
  }
 
  virtual Model::ListAccountsForProvisionedPermissionSetOutcome ListAccountsForProvisionedPermissionSet(
      const Model::ListAccountsForProvisionedPermissionSetRequest& request) const;
 
  template <typename ListAccountsForProvisionedPermissionSetRequestT = Model::ListAccountsForProvisionedPermissionSetRequest>
  Model::ListAccountsForProvisionedPermissionSetOutcomeCallable ListAccountsForProvisionedPermissionSetCallable(
      const ListAccountsForProvisionedPermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListAccountsForProvisionedPermissionSet, request);
  }
 
  template <typename ListAccountsForProvisionedPermissionSetRequestT = Model::ListAccountsForProvisionedPermissionSetRequest>
  void ListAccountsForProvisionedPermissionSetAsync(const ListAccountsForProvisionedPermissionSetRequestT& request,
                                                    const ListAccountsForProvisionedPermissionSetResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListAccountsForProvisionedPermissionSet, request, handler, context);
  }
 
  virtual Model::ListApplicationAccessScopesOutcome ListApplicationAccessScopes(
      const Model::ListApplicationAccessScopesRequest& request) const;
 
  template <typename ListApplicationAccessScopesRequestT = Model::ListApplicationAccessScopesRequest>
  Model::ListApplicationAccessScopesOutcomeCallable ListApplicationAccessScopesCallable(
      const ListApplicationAccessScopesRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListApplicationAccessScopes, request);
  }
 
  template <typename ListApplicationAccessScopesRequestT = Model::ListApplicationAccessScopesRequest>
  void ListApplicationAccessScopesAsync(const ListApplicationAccessScopesRequestT& request,
                                        const ListApplicationAccessScopesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListApplicationAccessScopes, request, handler, context);
  }
 
  virtual Model::ListApplicationAssignmentsOutcome ListApplicationAssignments(
      const Model::ListApplicationAssignmentsRequest& request) const;
 
  template <typename ListApplicationAssignmentsRequestT = Model::ListApplicationAssignmentsRequest>
  Model::ListApplicationAssignmentsOutcomeCallable ListApplicationAssignmentsCallable(
      const ListApplicationAssignmentsRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListApplicationAssignments, request);
  }
 
  template <typename ListApplicationAssignmentsRequestT = Model::ListApplicationAssignmentsRequest>
  void ListApplicationAssignmentsAsync(const ListApplicationAssignmentsRequestT& request,
                                       const ListApplicationAssignmentsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListApplicationAssignments, request, handler, context);
  }
 
  virtual Model::ListApplicationAssignmentsForPrincipalOutcome ListApplicationAssignmentsForPrincipal(
      const Model::ListApplicationAssignmentsForPrincipalRequest& request) const;
 
  template <typename ListApplicationAssignmentsForPrincipalRequestT = Model::ListApplicationAssignmentsForPrincipalRequest>
  Model::ListApplicationAssignmentsForPrincipalOutcomeCallable ListApplicationAssignmentsForPrincipalCallable(
      const ListApplicationAssignmentsForPrincipalRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListApplicationAssignmentsForPrincipal, request);
  }
 
  template <typename ListApplicationAssignmentsForPrincipalRequestT = Model::ListApplicationAssignmentsForPrincipalRequest>
  void ListApplicationAssignmentsForPrincipalAsync(const ListApplicationAssignmentsForPrincipalRequestT& request,
                                                   const ListApplicationAssignmentsForPrincipalResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListApplicationAssignmentsForPrincipal, request, handler, context);
  }
 
  virtual Model::ListApplicationAuthenticationMethodsOutcome ListApplicationAuthenticationMethods(
      const Model::ListApplicationAuthenticationMethodsRequest& request) const;
 
  template <typename ListApplicationAuthenticationMethodsRequestT = Model::ListApplicationAuthenticationMethodsRequest>
  Model::ListApplicationAuthenticationMethodsOutcomeCallable ListApplicationAuthenticationMethodsCallable(
      const ListApplicationAuthenticationMethodsRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListApplicationAuthenticationMethods, request);
  }
 
  template <typename ListApplicationAuthenticationMethodsRequestT = Model::ListApplicationAuthenticationMethodsRequest>
  void ListApplicationAuthenticationMethodsAsync(const ListApplicationAuthenticationMethodsRequestT& request,
                                                 const ListApplicationAuthenticationMethodsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListApplicationAuthenticationMethods, request, handler, context);
  }
 
  virtual Model::ListApplicationGrantsOutcome ListApplicationGrants(const Model::ListApplicationGrantsRequest& request) const;
 
  template <typename ListApplicationGrantsRequestT = Model::ListApplicationGrantsRequest>
  Model::ListApplicationGrantsOutcomeCallable ListApplicationGrantsCallable(const ListApplicationGrantsRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListApplicationGrants, request);
  }
 
  template <typename ListApplicationGrantsRequestT = Model::ListApplicationGrantsRequest>
  void ListApplicationGrantsAsync(const ListApplicationGrantsRequestT& request, const ListApplicationGrantsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListApplicationGrants, request, handler, context);
  }
 
  virtual Model::ListApplicationProvidersOutcome ListApplicationProviders(const Model::ListApplicationProvidersRequest& request = {}) const;
 
  template <typename ListApplicationProvidersRequestT = Model::ListApplicationProvidersRequest>
  Model::ListApplicationProvidersOutcomeCallable ListApplicationProvidersCallable(
      const ListApplicationProvidersRequestT& request = {}) const {
    return SubmitCallable(&SSOAdminClient::ListApplicationProviders, request);
  }
 
  template <typename ListApplicationProvidersRequestT = Model::ListApplicationProvidersRequest>
  void ListApplicationProvidersAsync(const ListApplicationProvidersResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListApplicationProvidersRequestT& request = {}) const {
    return SubmitAsync(&SSOAdminClient::ListApplicationProviders, request, handler, context);
  }
 
  virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request) const;
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListApplications, request);
  }
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  void ListApplicationsAsync(const ListApplicationsRequestT& request, const ListApplicationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListApplications, request, handler, context);
  }
 
  virtual Model::ListCustomerManagedPolicyReferencesInPermissionSetOutcome ListCustomerManagedPolicyReferencesInPermissionSet(
      const Model::ListCustomerManagedPolicyReferencesInPermissionSetRequest& request) const;
 
  template <typename ListCustomerManagedPolicyReferencesInPermissionSetRequestT =
                Model::ListCustomerManagedPolicyReferencesInPermissionSetRequest>
  Model::ListCustomerManagedPolicyReferencesInPermissionSetOutcomeCallable ListCustomerManagedPolicyReferencesInPermissionSetCallable(
      const ListCustomerManagedPolicyReferencesInPermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListCustomerManagedPolicyReferencesInPermissionSet, request);
  }
 
  template <typename ListCustomerManagedPolicyReferencesInPermissionSetRequestT =
                Model::ListCustomerManagedPolicyReferencesInPermissionSetRequest>
  void ListCustomerManagedPolicyReferencesInPermissionSetAsync(
      const ListCustomerManagedPolicyReferencesInPermissionSetRequestT& request,
      const ListCustomerManagedPolicyReferencesInPermissionSetResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListCustomerManagedPolicyReferencesInPermissionSet, request, handler, context);
  }
 
  virtual Model::ListInstancesOutcome ListInstances(const Model::ListInstancesRequest& request = {}) const;
 
  template <typename ListInstancesRequestT = Model::ListInstancesRequest>
  Model::ListInstancesOutcomeCallable ListInstancesCallable(const ListInstancesRequestT& request = {}) const {
    return SubmitCallable(&SSOAdminClient::ListInstances, request);
  }
 
  template <typename ListInstancesRequestT = Model::ListInstancesRequest>
  void ListInstancesAsync(const ListInstancesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListInstancesRequestT& request = {}) const {
    return SubmitAsync(&SSOAdminClient::ListInstances, request, handler, context);
  }
 
  virtual Model::ListManagedPoliciesInPermissionSetOutcome ListManagedPoliciesInPermissionSet(
      const Model::ListManagedPoliciesInPermissionSetRequest& request) const;
 
  template <typename ListManagedPoliciesInPermissionSetRequestT = Model::ListManagedPoliciesInPermissionSetRequest>
  Model::ListManagedPoliciesInPermissionSetOutcomeCallable ListManagedPoliciesInPermissionSetCallable(
      const ListManagedPoliciesInPermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListManagedPoliciesInPermissionSet, request);
  }
 
  template <typename ListManagedPoliciesInPermissionSetRequestT = Model::ListManagedPoliciesInPermissionSetRequest>
  void ListManagedPoliciesInPermissionSetAsync(const ListManagedPoliciesInPermissionSetRequestT& request,
                                               const ListManagedPoliciesInPermissionSetResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListManagedPoliciesInPermissionSet, request, handler, context);
  }
 
  virtual Model::ListPermissionSetProvisioningStatusOutcome ListPermissionSetProvisioningStatus(
      const Model::ListPermissionSetProvisioningStatusRequest& request) const;
 
  template <typename ListPermissionSetProvisioningStatusRequestT = Model::ListPermissionSetProvisioningStatusRequest>
  Model::ListPermissionSetProvisioningStatusOutcomeCallable ListPermissionSetProvisioningStatusCallable(
      const ListPermissionSetProvisioningStatusRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListPermissionSetProvisioningStatus, request);
  }
 
  template <typename ListPermissionSetProvisioningStatusRequestT = Model::ListPermissionSetProvisioningStatusRequest>
  void ListPermissionSetProvisioningStatusAsync(const ListPermissionSetProvisioningStatusRequestT& request,
                                                const ListPermissionSetProvisioningStatusResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListPermissionSetProvisioningStatus, request, handler, context);
  }
 
  virtual Model::ListPermissionSetsOutcome ListPermissionSets(const Model::ListPermissionSetsRequest& request) const;
 
  template <typename ListPermissionSetsRequestT = Model::ListPermissionSetsRequest>
  Model::ListPermissionSetsOutcomeCallable ListPermissionSetsCallable(const ListPermissionSetsRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListPermissionSets, request);
  }
 
  template <typename ListPermissionSetsRequestT = Model::ListPermissionSetsRequest>
  void ListPermissionSetsAsync(const ListPermissionSetsRequestT& request, const ListPermissionSetsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListPermissionSets, request, handler, context);
  }
 
  virtual Model::ListPermissionSetsProvisionedToAccountOutcome ListPermissionSetsProvisionedToAccount(
      const Model::ListPermissionSetsProvisionedToAccountRequest& request) const;
 
  template <typename ListPermissionSetsProvisionedToAccountRequestT = Model::ListPermissionSetsProvisionedToAccountRequest>
  Model::ListPermissionSetsProvisionedToAccountOutcomeCallable ListPermissionSetsProvisionedToAccountCallable(
      const ListPermissionSetsProvisionedToAccountRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListPermissionSetsProvisionedToAccount, request);
  }
 
  template <typename ListPermissionSetsProvisionedToAccountRequestT = Model::ListPermissionSetsProvisionedToAccountRequest>
  void ListPermissionSetsProvisionedToAccountAsync(const ListPermissionSetsProvisionedToAccountRequestT& request,
                                                   const ListPermissionSetsProvisionedToAccountResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListPermissionSetsProvisionedToAccount, request, handler, context);
  }
 
  virtual Model::ListRegionsOutcome ListRegions(const Model::ListRegionsRequest& request) const;
 
  template <typename ListRegionsRequestT = Model::ListRegionsRequest>
  Model::ListRegionsOutcomeCallable ListRegionsCallable(const ListRegionsRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListRegions, request);
  }
 
  template <typename ListRegionsRequestT = Model::ListRegionsRequest>
  void ListRegionsAsync(const ListRegionsRequestT& request, const ListRegionsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListRegions, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTrustedTokenIssuersOutcome ListTrustedTokenIssuers(const Model::ListTrustedTokenIssuersRequest& request) const;
 
  template <typename ListTrustedTokenIssuersRequestT = Model::ListTrustedTokenIssuersRequest>
  Model::ListTrustedTokenIssuersOutcomeCallable ListTrustedTokenIssuersCallable(const ListTrustedTokenIssuersRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ListTrustedTokenIssuers, request);
  }
 
  template <typename ListTrustedTokenIssuersRequestT = Model::ListTrustedTokenIssuersRequest>
  void ListTrustedTokenIssuersAsync(const ListTrustedTokenIssuersRequestT& request,
                                    const ListTrustedTokenIssuersResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ListTrustedTokenIssuers, request, handler, context);
  }
 
  virtual Model::ProvisionPermissionSetOutcome ProvisionPermissionSet(const Model::ProvisionPermissionSetRequest& request) const;
 
  template <typename ProvisionPermissionSetRequestT = Model::ProvisionPermissionSetRequest>
  Model::ProvisionPermissionSetOutcomeCallable ProvisionPermissionSetCallable(const ProvisionPermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::ProvisionPermissionSet, request);
  }
 
  template <typename ProvisionPermissionSetRequestT = Model::ProvisionPermissionSetRequest>
  void ProvisionPermissionSetAsync(const ProvisionPermissionSetRequestT& request,
                                   const ProvisionPermissionSetResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::ProvisionPermissionSet, request, handler, context);
  }
 
  virtual Model::PutApplicationAccessScopeOutcome PutApplicationAccessScope(const Model::PutApplicationAccessScopeRequest& request) const;
 
  template <typename PutApplicationAccessScopeRequestT = Model::PutApplicationAccessScopeRequest>
  Model::PutApplicationAccessScopeOutcomeCallable PutApplicationAccessScopeCallable(
      const PutApplicationAccessScopeRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::PutApplicationAccessScope, request);
  }
 
  template <typename PutApplicationAccessScopeRequestT = Model::PutApplicationAccessScopeRequest>
  void PutApplicationAccessScopeAsync(const PutApplicationAccessScopeRequestT& request,
                                      const PutApplicationAccessScopeResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::PutApplicationAccessScope, request, handler, context);
  }
 
  virtual Model::PutApplicationAssignmentConfigurationOutcome PutApplicationAssignmentConfiguration(
      const Model::PutApplicationAssignmentConfigurationRequest& request) const;
 
  template <typename PutApplicationAssignmentConfigurationRequestT = Model::PutApplicationAssignmentConfigurationRequest>
  Model::PutApplicationAssignmentConfigurationOutcomeCallable PutApplicationAssignmentConfigurationCallable(
      const PutApplicationAssignmentConfigurationRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::PutApplicationAssignmentConfiguration, request);
  }
 
  template <typename PutApplicationAssignmentConfigurationRequestT = Model::PutApplicationAssignmentConfigurationRequest>
  void PutApplicationAssignmentConfigurationAsync(const PutApplicationAssignmentConfigurationRequestT& request,
                                                  const PutApplicationAssignmentConfigurationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::PutApplicationAssignmentConfiguration, request, handler, context);
  }
 
  virtual Model::PutApplicationAuthenticationMethodOutcome PutApplicationAuthenticationMethod(
      const Model::PutApplicationAuthenticationMethodRequest& request) const;
 
  template <typename PutApplicationAuthenticationMethodRequestT = Model::PutApplicationAuthenticationMethodRequest>
  Model::PutApplicationAuthenticationMethodOutcomeCallable PutApplicationAuthenticationMethodCallable(
      const PutApplicationAuthenticationMethodRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::PutApplicationAuthenticationMethod, request);
  }
 
  template <typename PutApplicationAuthenticationMethodRequestT = Model::PutApplicationAuthenticationMethodRequest>
  void PutApplicationAuthenticationMethodAsync(const PutApplicationAuthenticationMethodRequestT& request,
                                               const PutApplicationAuthenticationMethodResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::PutApplicationAuthenticationMethod, request, handler, context);
  }
 
  virtual Model::PutApplicationGrantOutcome PutApplicationGrant(const Model::PutApplicationGrantRequest& request) const;
 
  template <typename PutApplicationGrantRequestT = Model::PutApplicationGrantRequest>
  Model::PutApplicationGrantOutcomeCallable PutApplicationGrantCallable(const PutApplicationGrantRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::PutApplicationGrant, request);
  }
 
  template <typename PutApplicationGrantRequestT = Model::PutApplicationGrantRequest>
  void PutApplicationGrantAsync(const PutApplicationGrantRequestT& request, const PutApplicationGrantResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::PutApplicationGrant, request, handler, context);
  }
 
  virtual Model::PutApplicationSessionConfigurationOutcome PutApplicationSessionConfiguration(
      const Model::PutApplicationSessionConfigurationRequest& request) const;
 
  template <typename PutApplicationSessionConfigurationRequestT = Model::PutApplicationSessionConfigurationRequest>
  Model::PutApplicationSessionConfigurationOutcomeCallable PutApplicationSessionConfigurationCallable(
      const PutApplicationSessionConfigurationRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::PutApplicationSessionConfiguration, request);
  }
 
  template <typename PutApplicationSessionConfigurationRequestT = Model::PutApplicationSessionConfigurationRequest>
  void PutApplicationSessionConfigurationAsync(const PutApplicationSessionConfigurationRequestT& request,
                                               const PutApplicationSessionConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::PutApplicationSessionConfiguration, request, handler, context);
  }
 
  virtual Model::PutInlinePolicyToPermissionSetOutcome PutInlinePolicyToPermissionSet(
      const Model::PutInlinePolicyToPermissionSetRequest& request) const;
 
  template <typename PutInlinePolicyToPermissionSetRequestT = Model::PutInlinePolicyToPermissionSetRequest>
  Model::PutInlinePolicyToPermissionSetOutcomeCallable PutInlinePolicyToPermissionSetCallable(
      const PutInlinePolicyToPermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::PutInlinePolicyToPermissionSet, request);
  }
 
  template <typename PutInlinePolicyToPermissionSetRequestT = Model::PutInlinePolicyToPermissionSetRequest>
  void PutInlinePolicyToPermissionSetAsync(const PutInlinePolicyToPermissionSetRequestT& request,
                                           const PutInlinePolicyToPermissionSetResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::PutInlinePolicyToPermissionSet, request, handler, context);
  }
 
  virtual Model::PutPermissionsBoundaryToPermissionSetOutcome PutPermissionsBoundaryToPermissionSet(
      const Model::PutPermissionsBoundaryToPermissionSetRequest& request) const;
 
  template <typename PutPermissionsBoundaryToPermissionSetRequestT = Model::PutPermissionsBoundaryToPermissionSetRequest>
  Model::PutPermissionsBoundaryToPermissionSetOutcomeCallable PutPermissionsBoundaryToPermissionSetCallable(
      const PutPermissionsBoundaryToPermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::PutPermissionsBoundaryToPermissionSet, request);
  }
 
  template <typename PutPermissionsBoundaryToPermissionSetRequestT = Model::PutPermissionsBoundaryToPermissionSetRequest>
  void PutPermissionsBoundaryToPermissionSetAsync(const PutPermissionsBoundaryToPermissionSetRequestT& request,
                                                  const PutPermissionsBoundaryToPermissionSetResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::PutPermissionsBoundaryToPermissionSet, request, handler, context);
  }
 
  virtual Model::RemoveRegionOutcome RemoveRegion(const Model::RemoveRegionRequest& request) const;
 
  template <typename RemoveRegionRequestT = Model::RemoveRegionRequest>
  Model::RemoveRegionOutcomeCallable RemoveRegionCallable(const RemoveRegionRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::RemoveRegion, request);
  }
 
  template <typename RemoveRegionRequestT = Model::RemoveRegionRequest>
  void RemoveRegionAsync(const RemoveRegionRequestT& request, const RemoveRegionResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::RemoveRegion, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::TagResource, request);
  }
 
  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(&SSOAdminClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::UntagResource, request);
  }
 
  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(&SSOAdminClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const;
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::UpdateApplication, request);
  }
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::UpdateApplication, request, handler, context);
  }
 
  virtual Model::UpdateInstanceOutcome UpdateInstance(const Model::UpdateInstanceRequest& request) const;
 
  template <typename UpdateInstanceRequestT = Model::UpdateInstanceRequest>
  Model::UpdateInstanceOutcomeCallable UpdateInstanceCallable(const UpdateInstanceRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::UpdateInstance, request);
  }
 
  template <typename UpdateInstanceRequestT = Model::UpdateInstanceRequest>
  void UpdateInstanceAsync(const UpdateInstanceRequestT& request, const UpdateInstanceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::UpdateInstance, request, handler, context);
  }
 
  virtual Model::UpdateInstanceAccessControlAttributeConfigurationOutcome UpdateInstanceAccessControlAttributeConfiguration(
      const Model::UpdateInstanceAccessControlAttributeConfigurationRequest& request) const;
 
  template <
      typename UpdateInstanceAccessControlAttributeConfigurationRequestT = Model::UpdateInstanceAccessControlAttributeConfigurationRequest>
  Model::UpdateInstanceAccessControlAttributeConfigurationOutcomeCallable UpdateInstanceAccessControlAttributeConfigurationCallable(
      const UpdateInstanceAccessControlAttributeConfigurationRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::UpdateInstanceAccessControlAttributeConfiguration, request);
  }
 
  template <
      typename UpdateInstanceAccessControlAttributeConfigurationRequestT = Model::UpdateInstanceAccessControlAttributeConfigurationRequest>
  void UpdateInstanceAccessControlAttributeConfigurationAsync(
      const UpdateInstanceAccessControlAttributeConfigurationRequestT& request,
      const UpdateInstanceAccessControlAttributeConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::UpdateInstanceAccessControlAttributeConfiguration, request, handler, context);
  }
 
  virtual Model::UpdatePermissionSetOutcome UpdatePermissionSet(const Model::UpdatePermissionSetRequest& request) const;
 
  template <typename UpdatePermissionSetRequestT = Model::UpdatePermissionSetRequest>
  Model::UpdatePermissionSetOutcomeCallable UpdatePermissionSetCallable(const UpdatePermissionSetRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::UpdatePermissionSet, request);
  }
 
  template <typename UpdatePermissionSetRequestT = Model::UpdatePermissionSetRequest>
  void UpdatePermissionSetAsync(const UpdatePermissionSetRequestT& request, const UpdatePermissionSetResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::UpdatePermissionSet, request, handler, context);
  }
 
  virtual Model::UpdateTrustedTokenIssuerOutcome UpdateTrustedTokenIssuer(const Model::UpdateTrustedTokenIssuerRequest& request) const;
 
  template <typename UpdateTrustedTokenIssuerRequestT = Model::UpdateTrustedTokenIssuerRequest>
  Model::UpdateTrustedTokenIssuerOutcomeCallable UpdateTrustedTokenIssuerCallable(const UpdateTrustedTokenIssuerRequestT& request) const {
    return SubmitCallable(&SSOAdminClient::UpdateTrustedTokenIssuer, request);
  }
 
  template <typename UpdateTrustedTokenIssuerRequestT = Model::UpdateTrustedTokenIssuerRequest>
  void UpdateTrustedTokenIssuerAsync(const UpdateTrustedTokenIssuerRequestT& request,
                                     const UpdateTrustedTokenIssuerResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOAdminClient::UpdateTrustedTokenIssuer, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SSOAdminEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SSOAdminClient>;
  void init(const SSOAdminClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SSOAdminError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  SSOAdminClientConfiguration m_clientConfiguration;
  std::shared_ptr<SSOAdminEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SSOAdmin
}  // namespace Aws