DirectoryServiceClient.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/ds/DirectoryServicePaginationBase.h>
#include <aws/ds/DirectoryServiceServiceClientModel.h>
#include <aws/ds/DirectoryServiceWaiter.h>
#include <aws/ds/DirectoryService_EXPORTS.h>
 
namespace Aws {
namespace DirectoryService {
class AWS_DIRECTORYSERVICE_API DirectoryServiceClient : public Aws::Client::AWSJsonClient,
                                                        public Aws::Client::ClientWithAsyncTemplateMethods<DirectoryServiceClient>,
                                                        public DirectoryServicePaginationBase<DirectoryServiceClient>,
                                                        public DirectoryServiceWaiter<DirectoryServiceClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef DirectoryServiceClientConfiguration ClientConfigurationType;
  typedef DirectoryServiceEndpointProvider EndpointProviderType;
 
  DirectoryServiceClient(const Aws::DirectoryService::DirectoryServiceClientConfiguration& clientConfiguration =
                             Aws::DirectoryService::DirectoryServiceClientConfiguration(),
                         std::shared_ptr<DirectoryServiceEndpointProviderBase> endpointProvider = nullptr);
 
  DirectoryServiceClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<DirectoryServiceEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::DirectoryService::DirectoryServiceClientConfiguration& clientConfiguration =
                             Aws::DirectoryService::DirectoryServiceClientConfiguration());
 
  DirectoryServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<DirectoryServiceEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::DirectoryService::DirectoryServiceClientConfiguration& clientConfiguration =
                             Aws::DirectoryService::DirectoryServiceClientConfiguration());
 
  /* Legacy constructors due deprecation */
  DirectoryServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DirectoryServiceClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DirectoryServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~DirectoryServiceClient();
 
  virtual Model::AcceptSharedDirectoryOutcome AcceptSharedDirectory(const Model::AcceptSharedDirectoryRequest& request) const;
 
  template <typename AcceptSharedDirectoryRequestT = Model::AcceptSharedDirectoryRequest>
  Model::AcceptSharedDirectoryOutcomeCallable AcceptSharedDirectoryCallable(const AcceptSharedDirectoryRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::AcceptSharedDirectory, request);
  }
 
  template <typename AcceptSharedDirectoryRequestT = Model::AcceptSharedDirectoryRequest>
  void AcceptSharedDirectoryAsync(const AcceptSharedDirectoryRequestT& request, const AcceptSharedDirectoryResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::AcceptSharedDirectory, request, handler, context);
  }
 
  virtual Model::AddIpRoutesOutcome AddIpRoutes(const Model::AddIpRoutesRequest& request) const;
 
  template <typename AddIpRoutesRequestT = Model::AddIpRoutesRequest>
  Model::AddIpRoutesOutcomeCallable AddIpRoutesCallable(const AddIpRoutesRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::AddIpRoutes, request);
  }
 
  template <typename AddIpRoutesRequestT = Model::AddIpRoutesRequest>
  void AddIpRoutesAsync(const AddIpRoutesRequestT& request, const AddIpRoutesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::AddIpRoutes, request, handler, context);
  }
 
  virtual Model::AddRegionOutcome AddRegion(const Model::AddRegionRequest& request) const;
 
  template <typename AddRegionRequestT = Model::AddRegionRequest>
  Model::AddRegionOutcomeCallable AddRegionCallable(const AddRegionRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::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(&DirectoryServiceClient::AddRegion, request, handler, context);
  }
 
  virtual Model::AddTagsToResourceOutcome AddTagsToResource(const Model::AddTagsToResourceRequest& request) const;
 
  template <typename AddTagsToResourceRequestT = Model::AddTagsToResourceRequest>
  Model::AddTagsToResourceOutcomeCallable AddTagsToResourceCallable(const AddTagsToResourceRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::AddTagsToResource, request);
  }
 
  template <typename AddTagsToResourceRequestT = Model::AddTagsToResourceRequest>
  void AddTagsToResourceAsync(const AddTagsToResourceRequestT& request, const AddTagsToResourceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::AddTagsToResource, request, handler, context);
  }
 
  virtual Model::CancelSchemaExtensionOutcome CancelSchemaExtension(const Model::CancelSchemaExtensionRequest& request) const;
 
  template <typename CancelSchemaExtensionRequestT = Model::CancelSchemaExtensionRequest>
  Model::CancelSchemaExtensionOutcomeCallable CancelSchemaExtensionCallable(const CancelSchemaExtensionRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::CancelSchemaExtension, request);
  }
 
  template <typename CancelSchemaExtensionRequestT = Model::CancelSchemaExtensionRequest>
  void CancelSchemaExtensionAsync(const CancelSchemaExtensionRequestT& request, const CancelSchemaExtensionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::CancelSchemaExtension, request, handler, context);
  }
 
  virtual Model::ConnectDirectoryOutcome ConnectDirectory(const Model::ConnectDirectoryRequest& request) const;
 
  template <typename ConnectDirectoryRequestT = Model::ConnectDirectoryRequest>
  Model::ConnectDirectoryOutcomeCallable ConnectDirectoryCallable(const ConnectDirectoryRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::ConnectDirectory, request);
  }
 
  template <typename ConnectDirectoryRequestT = Model::ConnectDirectoryRequest>
  void ConnectDirectoryAsync(const ConnectDirectoryRequestT& request, const ConnectDirectoryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::ConnectDirectory, request, handler, context);
  }
 
  virtual Model::CreateAliasOutcome CreateAlias(const Model::CreateAliasRequest& request) const;
 
  template <typename CreateAliasRequestT = Model::CreateAliasRequest>
  Model::CreateAliasOutcomeCallable CreateAliasCallable(const CreateAliasRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::CreateAlias, request);
  }
 
  template <typename CreateAliasRequestT = Model::CreateAliasRequest>
  void CreateAliasAsync(const CreateAliasRequestT& request, const CreateAliasResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::CreateAlias, request, handler, context);
  }
 
  virtual Model::CreateComputerOutcome CreateComputer(const Model::CreateComputerRequest& request) const;
 
  template <typename CreateComputerRequestT = Model::CreateComputerRequest>
  Model::CreateComputerOutcomeCallable CreateComputerCallable(const CreateComputerRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::CreateComputer, request);
  }
 
  template <typename CreateComputerRequestT = Model::CreateComputerRequest>
  void CreateComputerAsync(const CreateComputerRequestT& request, const CreateComputerResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::CreateComputer, request, handler, context);
  }
 
  virtual Model::CreateConditionalForwarderOutcome CreateConditionalForwarder(
      const Model::CreateConditionalForwarderRequest& request) const;
 
  template <typename CreateConditionalForwarderRequestT = Model::CreateConditionalForwarderRequest>
  Model::CreateConditionalForwarderOutcomeCallable CreateConditionalForwarderCallable(
      const CreateConditionalForwarderRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::CreateConditionalForwarder, request);
  }
 
  template <typename CreateConditionalForwarderRequestT = Model::CreateConditionalForwarderRequest>
  void CreateConditionalForwarderAsync(const CreateConditionalForwarderRequestT& request,
                                       const CreateConditionalForwarderResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::CreateConditionalForwarder, request, handler, context);
  }
 
  virtual Model::CreateDirectoryOutcome CreateDirectory(const Model::CreateDirectoryRequest& request) const;
 
  template <typename CreateDirectoryRequestT = Model::CreateDirectoryRequest>
  Model::CreateDirectoryOutcomeCallable CreateDirectoryCallable(const CreateDirectoryRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::CreateDirectory, request);
  }
 
  template <typename CreateDirectoryRequestT = Model::CreateDirectoryRequest>
  void CreateDirectoryAsync(const CreateDirectoryRequestT& request, const CreateDirectoryResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::CreateDirectory, request, handler, context);
  }
 
  virtual Model::CreateHybridADOutcome CreateHybridAD(const Model::CreateHybridADRequest& request) const;
 
  template <typename CreateHybridADRequestT = Model::CreateHybridADRequest>
  Model::CreateHybridADOutcomeCallable CreateHybridADCallable(const CreateHybridADRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::CreateHybridAD, request);
  }
 
  template <typename CreateHybridADRequestT = Model::CreateHybridADRequest>
  void CreateHybridADAsync(const CreateHybridADRequestT& request, const CreateHybridADResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::CreateHybridAD, request, handler, context);
  }
 
  virtual Model::CreateLogSubscriptionOutcome CreateLogSubscription(const Model::CreateLogSubscriptionRequest& request) const;
 
  template <typename CreateLogSubscriptionRequestT = Model::CreateLogSubscriptionRequest>
  Model::CreateLogSubscriptionOutcomeCallable CreateLogSubscriptionCallable(const CreateLogSubscriptionRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::CreateLogSubscription, request);
  }
 
  template <typename CreateLogSubscriptionRequestT = Model::CreateLogSubscriptionRequest>
  void CreateLogSubscriptionAsync(const CreateLogSubscriptionRequestT& request, const CreateLogSubscriptionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::CreateLogSubscription, request, handler, context);
  }
 
  virtual Model::CreateMicrosoftADOutcome CreateMicrosoftAD(const Model::CreateMicrosoftADRequest& request) const;
 
  template <typename CreateMicrosoftADRequestT = Model::CreateMicrosoftADRequest>
  Model::CreateMicrosoftADOutcomeCallable CreateMicrosoftADCallable(const CreateMicrosoftADRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::CreateMicrosoftAD, request);
  }
 
  template <typename CreateMicrosoftADRequestT = Model::CreateMicrosoftADRequest>
  void CreateMicrosoftADAsync(const CreateMicrosoftADRequestT& request, const CreateMicrosoftADResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::CreateMicrosoftAD, request, handler, context);
  }
 
  virtual Model::CreateSnapshotOutcome CreateSnapshot(const Model::CreateSnapshotRequest& request) const;
 
  template <typename CreateSnapshotRequestT = Model::CreateSnapshotRequest>
  Model::CreateSnapshotOutcomeCallable CreateSnapshotCallable(const CreateSnapshotRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::CreateSnapshot, request);
  }
 
  template <typename CreateSnapshotRequestT = Model::CreateSnapshotRequest>
  void CreateSnapshotAsync(const CreateSnapshotRequestT& request, const CreateSnapshotResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::CreateSnapshot, request, handler, context);
  }
 
  virtual Model::CreateTrustOutcome CreateTrust(const Model::CreateTrustRequest& request) const;
 
  template <typename CreateTrustRequestT = Model::CreateTrustRequest>
  Model::CreateTrustOutcomeCallable CreateTrustCallable(const CreateTrustRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::CreateTrust, request);
  }
 
  template <typename CreateTrustRequestT = Model::CreateTrustRequest>
  void CreateTrustAsync(const CreateTrustRequestT& request, const CreateTrustResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::CreateTrust, request, handler, context);
  }
 
  virtual Model::DeleteADAssessmentOutcome DeleteADAssessment(const Model::DeleteADAssessmentRequest& request) const;
 
  template <typename DeleteADAssessmentRequestT = Model::DeleteADAssessmentRequest>
  Model::DeleteADAssessmentOutcomeCallable DeleteADAssessmentCallable(const DeleteADAssessmentRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DeleteADAssessment, request);
  }
 
  template <typename DeleteADAssessmentRequestT = Model::DeleteADAssessmentRequest>
  void DeleteADAssessmentAsync(const DeleteADAssessmentRequestT& request, const DeleteADAssessmentResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DeleteADAssessment, request, handler, context);
  }
 
  virtual Model::DeleteConditionalForwarderOutcome DeleteConditionalForwarder(
      const Model::DeleteConditionalForwarderRequest& request) const;
 
  template <typename DeleteConditionalForwarderRequestT = Model::DeleteConditionalForwarderRequest>
  Model::DeleteConditionalForwarderOutcomeCallable DeleteConditionalForwarderCallable(
      const DeleteConditionalForwarderRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DeleteConditionalForwarder, request);
  }
 
  template <typename DeleteConditionalForwarderRequestT = Model::DeleteConditionalForwarderRequest>
  void DeleteConditionalForwarderAsync(const DeleteConditionalForwarderRequestT& request,
                                       const DeleteConditionalForwarderResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DeleteConditionalForwarder, request, handler, context);
  }
 
  virtual Model::DeleteDirectoryOutcome DeleteDirectory(const Model::DeleteDirectoryRequest& request) const;
 
  template <typename DeleteDirectoryRequestT = Model::DeleteDirectoryRequest>
  Model::DeleteDirectoryOutcomeCallable DeleteDirectoryCallable(const DeleteDirectoryRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DeleteDirectory, request);
  }
 
  template <typename DeleteDirectoryRequestT = Model::DeleteDirectoryRequest>
  void DeleteDirectoryAsync(const DeleteDirectoryRequestT& request, const DeleteDirectoryResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DeleteDirectory, request, handler, context);
  }
 
  virtual Model::DeleteLogSubscriptionOutcome DeleteLogSubscription(const Model::DeleteLogSubscriptionRequest& request) const;
 
  template <typename DeleteLogSubscriptionRequestT = Model::DeleteLogSubscriptionRequest>
  Model::DeleteLogSubscriptionOutcomeCallable DeleteLogSubscriptionCallable(const DeleteLogSubscriptionRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DeleteLogSubscription, request);
  }
 
  template <typename DeleteLogSubscriptionRequestT = Model::DeleteLogSubscriptionRequest>
  void DeleteLogSubscriptionAsync(const DeleteLogSubscriptionRequestT& request, const DeleteLogSubscriptionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DeleteLogSubscription, request, handler, context);
  }
 
  virtual Model::DeleteSnapshotOutcome DeleteSnapshot(const Model::DeleteSnapshotRequest& request) const;
 
  template <typename DeleteSnapshotRequestT = Model::DeleteSnapshotRequest>
  Model::DeleteSnapshotOutcomeCallable DeleteSnapshotCallable(const DeleteSnapshotRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DeleteSnapshot, request);
  }
 
  template <typename DeleteSnapshotRequestT = Model::DeleteSnapshotRequest>
  void DeleteSnapshotAsync(const DeleteSnapshotRequestT& request, const DeleteSnapshotResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DeleteSnapshot, request, handler, context);
  }
 
  virtual Model::DeleteTrustOutcome DeleteTrust(const Model::DeleteTrustRequest& request) const;
 
  template <typename DeleteTrustRequestT = Model::DeleteTrustRequest>
  Model::DeleteTrustOutcomeCallable DeleteTrustCallable(const DeleteTrustRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DeleteTrust, request);
  }
 
  template <typename DeleteTrustRequestT = Model::DeleteTrustRequest>
  void DeleteTrustAsync(const DeleteTrustRequestT& request, const DeleteTrustResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DeleteTrust, request, handler, context);
  }
 
  virtual Model::DeregisterCertificateOutcome DeregisterCertificate(const Model::DeregisterCertificateRequest& request) const;
 
  template <typename DeregisterCertificateRequestT = Model::DeregisterCertificateRequest>
  Model::DeregisterCertificateOutcomeCallable DeregisterCertificateCallable(const DeregisterCertificateRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DeregisterCertificate, request);
  }
 
  template <typename DeregisterCertificateRequestT = Model::DeregisterCertificateRequest>
  void DeregisterCertificateAsync(const DeregisterCertificateRequestT& request, const DeregisterCertificateResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DeregisterCertificate, request, handler, context);
  }
 
  virtual Model::DeregisterEventTopicOutcome DeregisterEventTopic(const Model::DeregisterEventTopicRequest& request) const;
 
  template <typename DeregisterEventTopicRequestT = Model::DeregisterEventTopicRequest>
  Model::DeregisterEventTopicOutcomeCallable DeregisterEventTopicCallable(const DeregisterEventTopicRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DeregisterEventTopic, request);
  }
 
  template <typename DeregisterEventTopicRequestT = Model::DeregisterEventTopicRequest>
  void DeregisterEventTopicAsync(const DeregisterEventTopicRequestT& request, const DeregisterEventTopicResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DeregisterEventTopic, request, handler, context);
  }
 
  virtual Model::DescribeADAssessmentOutcome DescribeADAssessment(const Model::DescribeADAssessmentRequest& request) const;
 
  template <typename DescribeADAssessmentRequestT = Model::DescribeADAssessmentRequest>
  Model::DescribeADAssessmentOutcomeCallable DescribeADAssessmentCallable(const DescribeADAssessmentRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeADAssessment, request);
  }
 
  template <typename DescribeADAssessmentRequestT = Model::DescribeADAssessmentRequest>
  void DescribeADAssessmentAsync(const DescribeADAssessmentRequestT& request, const DescribeADAssessmentResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeADAssessment, request, handler, context);
  }
 
  virtual Model::DescribeCAEnrollmentPolicyOutcome DescribeCAEnrollmentPolicy(
      const Model::DescribeCAEnrollmentPolicyRequest& request) const;
 
  template <typename DescribeCAEnrollmentPolicyRequestT = Model::DescribeCAEnrollmentPolicyRequest>
  Model::DescribeCAEnrollmentPolicyOutcomeCallable DescribeCAEnrollmentPolicyCallable(
      const DescribeCAEnrollmentPolicyRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeCAEnrollmentPolicy, request);
  }
 
  template <typename DescribeCAEnrollmentPolicyRequestT = Model::DescribeCAEnrollmentPolicyRequest>
  void DescribeCAEnrollmentPolicyAsync(const DescribeCAEnrollmentPolicyRequestT& request,
                                       const DescribeCAEnrollmentPolicyResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeCAEnrollmentPolicy, request, handler, context);
  }
 
  virtual Model::DescribeCertificateOutcome DescribeCertificate(const Model::DescribeCertificateRequest& request) const;
 
  template <typename DescribeCertificateRequestT = Model::DescribeCertificateRequest>
  Model::DescribeCertificateOutcomeCallable DescribeCertificateCallable(const DescribeCertificateRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeCertificate, request);
  }
 
  template <typename DescribeCertificateRequestT = Model::DescribeCertificateRequest>
  void DescribeCertificateAsync(const DescribeCertificateRequestT& request, const DescribeCertificateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeCertificate, request, handler, context);
  }
 
  virtual Model::DescribeClientAuthenticationSettingsOutcome DescribeClientAuthenticationSettings(
      const Model::DescribeClientAuthenticationSettingsRequest& request) const;
 
  template <typename DescribeClientAuthenticationSettingsRequestT = Model::DescribeClientAuthenticationSettingsRequest>
  Model::DescribeClientAuthenticationSettingsOutcomeCallable DescribeClientAuthenticationSettingsCallable(
      const DescribeClientAuthenticationSettingsRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeClientAuthenticationSettings, request);
  }
 
  template <typename DescribeClientAuthenticationSettingsRequestT = Model::DescribeClientAuthenticationSettingsRequest>
  void DescribeClientAuthenticationSettingsAsync(const DescribeClientAuthenticationSettingsRequestT& request,
                                                 const DescribeClientAuthenticationSettingsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeClientAuthenticationSettings, request, handler, context);
  }
 
  virtual Model::DescribeConditionalForwardersOutcome DescribeConditionalForwarders(
      const Model::DescribeConditionalForwardersRequest& request) const;
 
  template <typename DescribeConditionalForwardersRequestT = Model::DescribeConditionalForwardersRequest>
  Model::DescribeConditionalForwardersOutcomeCallable DescribeConditionalForwardersCallable(
      const DescribeConditionalForwardersRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeConditionalForwarders, request);
  }
 
  template <typename DescribeConditionalForwardersRequestT = Model::DescribeConditionalForwardersRequest>
  void DescribeConditionalForwardersAsync(const DescribeConditionalForwardersRequestT& request,
                                          const DescribeConditionalForwardersResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeConditionalForwarders, request, handler, context);
  }
 
  virtual Model::DescribeDirectoriesOutcome DescribeDirectories(const Model::DescribeDirectoriesRequest& request = {}) const;
 
  template <typename DescribeDirectoriesRequestT = Model::DescribeDirectoriesRequest>
  Model::DescribeDirectoriesOutcomeCallable DescribeDirectoriesCallable(const DescribeDirectoriesRequestT& request = {}) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeDirectories, request);
  }
 
  template <typename DescribeDirectoriesRequestT = Model::DescribeDirectoriesRequest>
  void DescribeDirectoriesAsync(const DescribeDirectoriesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeDirectoriesRequestT& request = {}) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeDirectories, request, handler, context);
  }
 
  virtual Model::DescribeDirectoryDataAccessOutcome DescribeDirectoryDataAccess(
      const Model::DescribeDirectoryDataAccessRequest& request) const;
 
  template <typename DescribeDirectoryDataAccessRequestT = Model::DescribeDirectoryDataAccessRequest>
  Model::DescribeDirectoryDataAccessOutcomeCallable DescribeDirectoryDataAccessCallable(
      const DescribeDirectoryDataAccessRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeDirectoryDataAccess, request);
  }
 
  template <typename DescribeDirectoryDataAccessRequestT = Model::DescribeDirectoryDataAccessRequest>
  void DescribeDirectoryDataAccessAsync(const DescribeDirectoryDataAccessRequestT& request,
                                        const DescribeDirectoryDataAccessResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeDirectoryDataAccess, request, handler, context);
  }
 
  virtual Model::DescribeDomainControllersOutcome DescribeDomainControllers(const Model::DescribeDomainControllersRequest& request) const;
 
  template <typename DescribeDomainControllersRequestT = Model::DescribeDomainControllersRequest>
  Model::DescribeDomainControllersOutcomeCallable DescribeDomainControllersCallable(
      const DescribeDomainControllersRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeDomainControllers, request);
  }
 
  template <typename DescribeDomainControllersRequestT = Model::DescribeDomainControllersRequest>
  void DescribeDomainControllersAsync(const DescribeDomainControllersRequestT& request,
                                      const DescribeDomainControllersResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeDomainControllers, request, handler, context);
  }
 
  virtual Model::DescribeEventTopicsOutcome DescribeEventTopics(const Model::DescribeEventTopicsRequest& request = {}) const;
 
  template <typename DescribeEventTopicsRequestT = Model::DescribeEventTopicsRequest>
  Model::DescribeEventTopicsOutcomeCallable DescribeEventTopicsCallable(const DescribeEventTopicsRequestT& request = {}) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeEventTopics, request);
  }
 
  template <typename DescribeEventTopicsRequestT = Model::DescribeEventTopicsRequest>
  void DescribeEventTopicsAsync(const DescribeEventTopicsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeEventTopicsRequestT& request = {}) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeEventTopics, request, handler, context);
  }
 
  virtual Model::DescribeHybridADUpdateOutcome DescribeHybridADUpdate(const Model::DescribeHybridADUpdateRequest& request) const;
 
  template <typename DescribeHybridADUpdateRequestT = Model::DescribeHybridADUpdateRequest>
  Model::DescribeHybridADUpdateOutcomeCallable DescribeHybridADUpdateCallable(const DescribeHybridADUpdateRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeHybridADUpdate, request);
  }
 
  template <typename DescribeHybridADUpdateRequestT = Model::DescribeHybridADUpdateRequest>
  void DescribeHybridADUpdateAsync(const DescribeHybridADUpdateRequestT& request,
                                   const DescribeHybridADUpdateResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeHybridADUpdate, request, handler, context);
  }
 
  virtual Model::DescribeLDAPSSettingsOutcome DescribeLDAPSSettings(const Model::DescribeLDAPSSettingsRequest& request) const;
 
  template <typename DescribeLDAPSSettingsRequestT = Model::DescribeLDAPSSettingsRequest>
  Model::DescribeLDAPSSettingsOutcomeCallable DescribeLDAPSSettingsCallable(const DescribeLDAPSSettingsRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeLDAPSSettings, request);
  }
 
  template <typename DescribeLDAPSSettingsRequestT = Model::DescribeLDAPSSettingsRequest>
  void DescribeLDAPSSettingsAsync(const DescribeLDAPSSettingsRequestT& request, const DescribeLDAPSSettingsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeLDAPSSettings, request, handler, context);
  }
 
  virtual Model::DescribeRegionsOutcome DescribeRegions(const Model::DescribeRegionsRequest& request) const;
 
  template <typename DescribeRegionsRequestT = Model::DescribeRegionsRequest>
  Model::DescribeRegionsOutcomeCallable DescribeRegionsCallable(const DescribeRegionsRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeRegions, request);
  }
 
  template <typename DescribeRegionsRequestT = Model::DescribeRegionsRequest>
  void DescribeRegionsAsync(const DescribeRegionsRequestT& request, const DescribeRegionsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeRegions, request, handler, context);
  }
 
  virtual Model::DescribeSettingsOutcome DescribeSettings(const Model::DescribeSettingsRequest& request) const;
 
  template <typename DescribeSettingsRequestT = Model::DescribeSettingsRequest>
  Model::DescribeSettingsOutcomeCallable DescribeSettingsCallable(const DescribeSettingsRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeSettings, request);
  }
 
  template <typename DescribeSettingsRequestT = Model::DescribeSettingsRequest>
  void DescribeSettingsAsync(const DescribeSettingsRequestT& request, const DescribeSettingsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeSettings, request, handler, context);
  }
 
  virtual Model::DescribeSharedDirectoriesOutcome DescribeSharedDirectories(const Model::DescribeSharedDirectoriesRequest& request) const;
 
  template <typename DescribeSharedDirectoriesRequestT = Model::DescribeSharedDirectoriesRequest>
  Model::DescribeSharedDirectoriesOutcomeCallable DescribeSharedDirectoriesCallable(
      const DescribeSharedDirectoriesRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeSharedDirectories, request);
  }
 
  template <typename DescribeSharedDirectoriesRequestT = Model::DescribeSharedDirectoriesRequest>
  void DescribeSharedDirectoriesAsync(const DescribeSharedDirectoriesRequestT& request,
                                      const DescribeSharedDirectoriesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeSharedDirectories, request, handler, context);
  }
 
  virtual Model::DescribeSnapshotsOutcome DescribeSnapshots(const Model::DescribeSnapshotsRequest& request = {}) const;
 
  template <typename DescribeSnapshotsRequestT = Model::DescribeSnapshotsRequest>
  Model::DescribeSnapshotsOutcomeCallable DescribeSnapshotsCallable(const DescribeSnapshotsRequestT& request = {}) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeSnapshots, request);
  }
 
  template <typename DescribeSnapshotsRequestT = Model::DescribeSnapshotsRequest>
  void DescribeSnapshotsAsync(const DescribeSnapshotsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const DescribeSnapshotsRequestT& request = {}) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeSnapshots, request, handler, context);
  }
 
  virtual Model::DescribeTrustsOutcome DescribeTrusts(const Model::DescribeTrustsRequest& request = {}) const;
 
  template <typename DescribeTrustsRequestT = Model::DescribeTrustsRequest>
  Model::DescribeTrustsOutcomeCallable DescribeTrustsCallable(const DescribeTrustsRequestT& request = {}) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeTrusts, request);
  }
 
  template <typename DescribeTrustsRequestT = Model::DescribeTrustsRequest>
  void DescribeTrustsAsync(const DescribeTrustsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const DescribeTrustsRequestT& request = {}) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeTrusts, request, handler, context);
  }
 
  virtual Model::DescribeUpdateDirectoryOutcome DescribeUpdateDirectory(const Model::DescribeUpdateDirectoryRequest& request) const;
 
  template <typename DescribeUpdateDirectoryRequestT = Model::DescribeUpdateDirectoryRequest>
  Model::DescribeUpdateDirectoryOutcomeCallable DescribeUpdateDirectoryCallable(const DescribeUpdateDirectoryRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DescribeUpdateDirectory, request);
  }
 
  template <typename DescribeUpdateDirectoryRequestT = Model::DescribeUpdateDirectoryRequest>
  void DescribeUpdateDirectoryAsync(const DescribeUpdateDirectoryRequestT& request,
                                    const DescribeUpdateDirectoryResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DescribeUpdateDirectory, request, handler, context);
  }
 
  virtual Model::DisableCAEnrollmentPolicyOutcome DisableCAEnrollmentPolicy(const Model::DisableCAEnrollmentPolicyRequest& request) const;
 
  template <typename DisableCAEnrollmentPolicyRequestT = Model::DisableCAEnrollmentPolicyRequest>
  Model::DisableCAEnrollmentPolicyOutcomeCallable DisableCAEnrollmentPolicyCallable(
      const DisableCAEnrollmentPolicyRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DisableCAEnrollmentPolicy, request);
  }
 
  template <typename DisableCAEnrollmentPolicyRequestT = Model::DisableCAEnrollmentPolicyRequest>
  void DisableCAEnrollmentPolicyAsync(const DisableCAEnrollmentPolicyRequestT& request,
                                      const DisableCAEnrollmentPolicyResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DisableCAEnrollmentPolicy, request, handler, context);
  }
 
  virtual Model::DisableClientAuthenticationOutcome DisableClientAuthentication(
      const Model::DisableClientAuthenticationRequest& request) const;
 
  template <typename DisableClientAuthenticationRequestT = Model::DisableClientAuthenticationRequest>
  Model::DisableClientAuthenticationOutcomeCallable DisableClientAuthenticationCallable(
      const DisableClientAuthenticationRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DisableClientAuthentication, request);
  }
 
  template <typename DisableClientAuthenticationRequestT = Model::DisableClientAuthenticationRequest>
  void DisableClientAuthenticationAsync(const DisableClientAuthenticationRequestT& request,
                                        const DisableClientAuthenticationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DisableClientAuthentication, request, handler, context);
  }
 
  virtual Model::DisableDirectoryDataAccessOutcome DisableDirectoryDataAccess(
      const Model::DisableDirectoryDataAccessRequest& request) const;
 
  template <typename DisableDirectoryDataAccessRequestT = Model::DisableDirectoryDataAccessRequest>
  Model::DisableDirectoryDataAccessOutcomeCallable DisableDirectoryDataAccessCallable(
      const DisableDirectoryDataAccessRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DisableDirectoryDataAccess, request);
  }
 
  template <typename DisableDirectoryDataAccessRequestT = Model::DisableDirectoryDataAccessRequest>
  void DisableDirectoryDataAccessAsync(const DisableDirectoryDataAccessRequestT& request,
                                       const DisableDirectoryDataAccessResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DisableDirectoryDataAccess, request, handler, context);
  }
 
  virtual Model::DisableLDAPSOutcome DisableLDAPS(const Model::DisableLDAPSRequest& request) const;
 
  template <typename DisableLDAPSRequestT = Model::DisableLDAPSRequest>
  Model::DisableLDAPSOutcomeCallable DisableLDAPSCallable(const DisableLDAPSRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DisableLDAPS, request);
  }
 
  template <typename DisableLDAPSRequestT = Model::DisableLDAPSRequest>
  void DisableLDAPSAsync(const DisableLDAPSRequestT& request, const DisableLDAPSResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DisableLDAPS, request, handler, context);
  }
 
  virtual Model::DisableRadiusOutcome DisableRadius(const Model::DisableRadiusRequest& request) const;
 
  template <typename DisableRadiusRequestT = Model::DisableRadiusRequest>
  Model::DisableRadiusOutcomeCallable DisableRadiusCallable(const DisableRadiusRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DisableRadius, request);
  }
 
  template <typename DisableRadiusRequestT = Model::DisableRadiusRequest>
  void DisableRadiusAsync(const DisableRadiusRequestT& request, const DisableRadiusResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DisableRadius, request, handler, context);
  }
 
  virtual Model::DisableSsoOutcome DisableSso(const Model::DisableSsoRequest& request) const;
 
  template <typename DisableSsoRequestT = Model::DisableSsoRequest>
  Model::DisableSsoOutcomeCallable DisableSsoCallable(const DisableSsoRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::DisableSso, request);
  }
 
  template <typename DisableSsoRequestT = Model::DisableSsoRequest>
  void DisableSsoAsync(const DisableSsoRequestT& request, const DisableSsoResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::DisableSso, request, handler, context);
  }
 
  virtual Model::EnableCAEnrollmentPolicyOutcome EnableCAEnrollmentPolicy(const Model::EnableCAEnrollmentPolicyRequest& request) const;
 
  template <typename EnableCAEnrollmentPolicyRequestT = Model::EnableCAEnrollmentPolicyRequest>
  Model::EnableCAEnrollmentPolicyOutcomeCallable EnableCAEnrollmentPolicyCallable(const EnableCAEnrollmentPolicyRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::EnableCAEnrollmentPolicy, request);
  }
 
  template <typename EnableCAEnrollmentPolicyRequestT = Model::EnableCAEnrollmentPolicyRequest>
  void EnableCAEnrollmentPolicyAsync(const EnableCAEnrollmentPolicyRequestT& request,
                                     const EnableCAEnrollmentPolicyResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::EnableCAEnrollmentPolicy, request, handler, context);
  }
 
  virtual Model::EnableClientAuthenticationOutcome EnableClientAuthentication(
      const Model::EnableClientAuthenticationRequest& request) const;
 
  template <typename EnableClientAuthenticationRequestT = Model::EnableClientAuthenticationRequest>
  Model::EnableClientAuthenticationOutcomeCallable EnableClientAuthenticationCallable(
      const EnableClientAuthenticationRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::EnableClientAuthentication, request);
  }
 
  template <typename EnableClientAuthenticationRequestT = Model::EnableClientAuthenticationRequest>
  void EnableClientAuthenticationAsync(const EnableClientAuthenticationRequestT& request,
                                       const EnableClientAuthenticationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::EnableClientAuthentication, request, handler, context);
  }
 
  virtual Model::EnableDirectoryDataAccessOutcome EnableDirectoryDataAccess(const Model::EnableDirectoryDataAccessRequest& request) const;
 
  template <typename EnableDirectoryDataAccessRequestT = Model::EnableDirectoryDataAccessRequest>
  Model::EnableDirectoryDataAccessOutcomeCallable EnableDirectoryDataAccessCallable(
      const EnableDirectoryDataAccessRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::EnableDirectoryDataAccess, request);
  }
 
  template <typename EnableDirectoryDataAccessRequestT = Model::EnableDirectoryDataAccessRequest>
  void EnableDirectoryDataAccessAsync(const EnableDirectoryDataAccessRequestT& request,
                                      const EnableDirectoryDataAccessResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::EnableDirectoryDataAccess, request, handler, context);
  }
 
  virtual Model::EnableLDAPSOutcome EnableLDAPS(const Model::EnableLDAPSRequest& request) const;
 
  template <typename EnableLDAPSRequestT = Model::EnableLDAPSRequest>
  Model::EnableLDAPSOutcomeCallable EnableLDAPSCallable(const EnableLDAPSRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::EnableLDAPS, request);
  }
 
  template <typename EnableLDAPSRequestT = Model::EnableLDAPSRequest>
  void EnableLDAPSAsync(const EnableLDAPSRequestT& request, const EnableLDAPSResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::EnableLDAPS, request, handler, context);
  }
 
  virtual Model::EnableRadiusOutcome EnableRadius(const Model::EnableRadiusRequest& request) const;
 
  template <typename EnableRadiusRequestT = Model::EnableRadiusRequest>
  Model::EnableRadiusOutcomeCallable EnableRadiusCallable(const EnableRadiusRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::EnableRadius, request);
  }
 
  template <typename EnableRadiusRequestT = Model::EnableRadiusRequest>
  void EnableRadiusAsync(const EnableRadiusRequestT& request, const EnableRadiusResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::EnableRadius, request, handler, context);
  }
 
  virtual Model::EnableSsoOutcome EnableSso(const Model::EnableSsoRequest& request) const;
 
  template <typename EnableSsoRequestT = Model::EnableSsoRequest>
  Model::EnableSsoOutcomeCallable EnableSsoCallable(const EnableSsoRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::EnableSso, request);
  }
 
  template <typename EnableSsoRequestT = Model::EnableSsoRequest>
  void EnableSsoAsync(const EnableSsoRequestT& request, const EnableSsoResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::EnableSso, request, handler, context);
  }
 
  virtual Model::GetDirectoryLimitsOutcome GetDirectoryLimits(const Model::GetDirectoryLimitsRequest& request = {}) const;
 
  template <typename GetDirectoryLimitsRequestT = Model::GetDirectoryLimitsRequest>
  Model::GetDirectoryLimitsOutcomeCallable GetDirectoryLimitsCallable(const GetDirectoryLimitsRequestT& request = {}) const {
    return SubmitCallable(&DirectoryServiceClient::GetDirectoryLimits, request);
  }
 
  template <typename GetDirectoryLimitsRequestT = Model::GetDirectoryLimitsRequest>
  void GetDirectoryLimitsAsync(const GetDirectoryLimitsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const GetDirectoryLimitsRequestT& request = {}) const {
    return SubmitAsync(&DirectoryServiceClient::GetDirectoryLimits, request, handler, context);
  }
 
  virtual Model::GetSnapshotLimitsOutcome GetSnapshotLimits(const Model::GetSnapshotLimitsRequest& request) const;
 
  template <typename GetSnapshotLimitsRequestT = Model::GetSnapshotLimitsRequest>
  Model::GetSnapshotLimitsOutcomeCallable GetSnapshotLimitsCallable(const GetSnapshotLimitsRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::GetSnapshotLimits, request);
  }
 
  template <typename GetSnapshotLimitsRequestT = Model::GetSnapshotLimitsRequest>
  void GetSnapshotLimitsAsync(const GetSnapshotLimitsRequestT& request, const GetSnapshotLimitsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::GetSnapshotLimits, request, handler, context);
  }
 
  virtual Model::ListADAssessmentsOutcome ListADAssessments(const Model::ListADAssessmentsRequest& request = {}) const;
 
  template <typename ListADAssessmentsRequestT = Model::ListADAssessmentsRequest>
  Model::ListADAssessmentsOutcomeCallable ListADAssessmentsCallable(const ListADAssessmentsRequestT& request = {}) const {
    return SubmitCallable(&DirectoryServiceClient::ListADAssessments, request);
  }
 
  template <typename ListADAssessmentsRequestT = Model::ListADAssessmentsRequest>
  void ListADAssessmentsAsync(const ListADAssessmentsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListADAssessmentsRequestT& request = {}) const {
    return SubmitAsync(&DirectoryServiceClient::ListADAssessments, request, handler, context);
  }
 
  virtual Model::ListCertificatesOutcome ListCertificates(const Model::ListCertificatesRequest& request) const;
 
  template <typename ListCertificatesRequestT = Model::ListCertificatesRequest>
  Model::ListCertificatesOutcomeCallable ListCertificatesCallable(const ListCertificatesRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::ListCertificates, request);
  }
 
  template <typename ListCertificatesRequestT = Model::ListCertificatesRequest>
  void ListCertificatesAsync(const ListCertificatesRequestT& request, const ListCertificatesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::ListCertificates, request, handler, context);
  }
 
  virtual Model::ListIpRoutesOutcome ListIpRoutes(const Model::ListIpRoutesRequest& request) const;
 
  template <typename ListIpRoutesRequestT = Model::ListIpRoutesRequest>
  Model::ListIpRoutesOutcomeCallable ListIpRoutesCallable(const ListIpRoutesRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::ListIpRoutes, request);
  }
 
  template <typename ListIpRoutesRequestT = Model::ListIpRoutesRequest>
  void ListIpRoutesAsync(const ListIpRoutesRequestT& request, const ListIpRoutesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::ListIpRoutes, request, handler, context);
  }
 
  virtual Model::ListLogSubscriptionsOutcome ListLogSubscriptions(const Model::ListLogSubscriptionsRequest& request = {}) const;
 
  template <typename ListLogSubscriptionsRequestT = Model::ListLogSubscriptionsRequest>
  Model::ListLogSubscriptionsOutcomeCallable ListLogSubscriptionsCallable(const ListLogSubscriptionsRequestT& request = {}) const {
    return SubmitCallable(&DirectoryServiceClient::ListLogSubscriptions, request);
  }
 
  template <typename ListLogSubscriptionsRequestT = Model::ListLogSubscriptionsRequest>
  void ListLogSubscriptionsAsync(const ListLogSubscriptionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListLogSubscriptionsRequestT& request = {}) const {
    return SubmitAsync(&DirectoryServiceClient::ListLogSubscriptions, request, handler, context);
  }
 
  virtual Model::ListSchemaExtensionsOutcome ListSchemaExtensions(const Model::ListSchemaExtensionsRequest& request) const;
 
  template <typename ListSchemaExtensionsRequestT = Model::ListSchemaExtensionsRequest>
  Model::ListSchemaExtensionsOutcomeCallable ListSchemaExtensionsCallable(const ListSchemaExtensionsRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::ListSchemaExtensions, request);
  }
 
  template <typename ListSchemaExtensionsRequestT = Model::ListSchemaExtensionsRequest>
  void ListSchemaExtensionsAsync(const ListSchemaExtensionsRequestT& request, const ListSchemaExtensionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::ListSchemaExtensions, 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(&DirectoryServiceClient::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(&DirectoryServiceClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RegisterCertificateOutcome RegisterCertificate(const Model::RegisterCertificateRequest& request) const;
 
  template <typename RegisterCertificateRequestT = Model::RegisterCertificateRequest>
  Model::RegisterCertificateOutcomeCallable RegisterCertificateCallable(const RegisterCertificateRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::RegisterCertificate, request);
  }
 
  template <typename RegisterCertificateRequestT = Model::RegisterCertificateRequest>
  void RegisterCertificateAsync(const RegisterCertificateRequestT& request, const RegisterCertificateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::RegisterCertificate, request, handler, context);
  }
 
  virtual Model::RegisterEventTopicOutcome RegisterEventTopic(const Model::RegisterEventTopicRequest& request) const;
 
  template <typename RegisterEventTopicRequestT = Model::RegisterEventTopicRequest>
  Model::RegisterEventTopicOutcomeCallable RegisterEventTopicCallable(const RegisterEventTopicRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::RegisterEventTopic, request);
  }
 
  template <typename RegisterEventTopicRequestT = Model::RegisterEventTopicRequest>
  void RegisterEventTopicAsync(const RegisterEventTopicRequestT& request, const RegisterEventTopicResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::RegisterEventTopic, request, handler, context);
  }
 
  virtual Model::RejectSharedDirectoryOutcome RejectSharedDirectory(const Model::RejectSharedDirectoryRequest& request) const;
 
  template <typename RejectSharedDirectoryRequestT = Model::RejectSharedDirectoryRequest>
  Model::RejectSharedDirectoryOutcomeCallable RejectSharedDirectoryCallable(const RejectSharedDirectoryRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::RejectSharedDirectory, request);
  }
 
  template <typename RejectSharedDirectoryRequestT = Model::RejectSharedDirectoryRequest>
  void RejectSharedDirectoryAsync(const RejectSharedDirectoryRequestT& request, const RejectSharedDirectoryResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::RejectSharedDirectory, request, handler, context);
  }
 
  virtual Model::RemoveIpRoutesOutcome RemoveIpRoutes(const Model::RemoveIpRoutesRequest& request) const;
 
  template <typename RemoveIpRoutesRequestT = Model::RemoveIpRoutesRequest>
  Model::RemoveIpRoutesOutcomeCallable RemoveIpRoutesCallable(const RemoveIpRoutesRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::RemoveIpRoutes, request);
  }
 
  template <typename RemoveIpRoutesRequestT = Model::RemoveIpRoutesRequest>
  void RemoveIpRoutesAsync(const RemoveIpRoutesRequestT& request, const RemoveIpRoutesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::RemoveIpRoutes, 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(&DirectoryServiceClient::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(&DirectoryServiceClient::RemoveRegion, request, handler, context);
  }
 
  virtual Model::RemoveTagsFromResourceOutcome RemoveTagsFromResource(const Model::RemoveTagsFromResourceRequest& request) const;
 
  template <typename RemoveTagsFromResourceRequestT = Model::RemoveTagsFromResourceRequest>
  Model::RemoveTagsFromResourceOutcomeCallable RemoveTagsFromResourceCallable(const RemoveTagsFromResourceRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::RemoveTagsFromResource, request);
  }
 
  template <typename RemoveTagsFromResourceRequestT = Model::RemoveTagsFromResourceRequest>
  void RemoveTagsFromResourceAsync(const RemoveTagsFromResourceRequestT& request,
                                   const RemoveTagsFromResourceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::RemoveTagsFromResource, request, handler, context);
  }
 
  virtual Model::ResetUserPasswordOutcome ResetUserPassword(const Model::ResetUserPasswordRequest& request) const;
 
  template <typename ResetUserPasswordRequestT = Model::ResetUserPasswordRequest>
  Model::ResetUserPasswordOutcomeCallable ResetUserPasswordCallable(const ResetUserPasswordRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::ResetUserPassword, request);
  }
 
  template <typename ResetUserPasswordRequestT = Model::ResetUserPasswordRequest>
  void ResetUserPasswordAsync(const ResetUserPasswordRequestT& request, const ResetUserPasswordResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::ResetUserPassword, request, handler, context);
  }
 
  virtual Model::RestoreFromSnapshotOutcome RestoreFromSnapshot(const Model::RestoreFromSnapshotRequest& request) const;
 
  template <typename RestoreFromSnapshotRequestT = Model::RestoreFromSnapshotRequest>
  Model::RestoreFromSnapshotOutcomeCallable RestoreFromSnapshotCallable(const RestoreFromSnapshotRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::RestoreFromSnapshot, request);
  }
 
  template <typename RestoreFromSnapshotRequestT = Model::RestoreFromSnapshotRequest>
  void RestoreFromSnapshotAsync(const RestoreFromSnapshotRequestT& request, const RestoreFromSnapshotResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::RestoreFromSnapshot, request, handler, context);
  }
 
  virtual Model::ShareDirectoryOutcome ShareDirectory(const Model::ShareDirectoryRequest& request) const;
 
  template <typename ShareDirectoryRequestT = Model::ShareDirectoryRequest>
  Model::ShareDirectoryOutcomeCallable ShareDirectoryCallable(const ShareDirectoryRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::ShareDirectory, request);
  }
 
  template <typename ShareDirectoryRequestT = Model::ShareDirectoryRequest>
  void ShareDirectoryAsync(const ShareDirectoryRequestT& request, const ShareDirectoryResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::ShareDirectory, request, handler, context);
  }
 
  virtual Model::StartADAssessmentOutcome StartADAssessment(const Model::StartADAssessmentRequest& request = {}) const;
 
  template <typename StartADAssessmentRequestT = Model::StartADAssessmentRequest>
  Model::StartADAssessmentOutcomeCallable StartADAssessmentCallable(const StartADAssessmentRequestT& request = {}) const {
    return SubmitCallable(&DirectoryServiceClient::StartADAssessment, request);
  }
 
  template <typename StartADAssessmentRequestT = Model::StartADAssessmentRequest>
  void StartADAssessmentAsync(const StartADAssessmentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const StartADAssessmentRequestT& request = {}) const {
    return SubmitAsync(&DirectoryServiceClient::StartADAssessment, request, handler, context);
  }
 
  virtual Model::StartSchemaExtensionOutcome StartSchemaExtension(const Model::StartSchemaExtensionRequest& request) const;
 
  template <typename StartSchemaExtensionRequestT = Model::StartSchemaExtensionRequest>
  Model::StartSchemaExtensionOutcomeCallable StartSchemaExtensionCallable(const StartSchemaExtensionRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::StartSchemaExtension, request);
  }
 
  template <typename StartSchemaExtensionRequestT = Model::StartSchemaExtensionRequest>
  void StartSchemaExtensionAsync(const StartSchemaExtensionRequestT& request, const StartSchemaExtensionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::StartSchemaExtension, request, handler, context);
  }
 
  virtual Model::UnshareDirectoryOutcome UnshareDirectory(const Model::UnshareDirectoryRequest& request) const;
 
  template <typename UnshareDirectoryRequestT = Model::UnshareDirectoryRequest>
  Model::UnshareDirectoryOutcomeCallable UnshareDirectoryCallable(const UnshareDirectoryRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::UnshareDirectory, request);
  }
 
  template <typename UnshareDirectoryRequestT = Model::UnshareDirectoryRequest>
  void UnshareDirectoryAsync(const UnshareDirectoryRequestT& request, const UnshareDirectoryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::UnshareDirectory, request, handler, context);
  }
 
  virtual Model::UpdateConditionalForwarderOutcome UpdateConditionalForwarder(
      const Model::UpdateConditionalForwarderRequest& request) const;
 
  template <typename UpdateConditionalForwarderRequestT = Model::UpdateConditionalForwarderRequest>
  Model::UpdateConditionalForwarderOutcomeCallable UpdateConditionalForwarderCallable(
      const UpdateConditionalForwarderRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::UpdateConditionalForwarder, request);
  }
 
  template <typename UpdateConditionalForwarderRequestT = Model::UpdateConditionalForwarderRequest>
  void UpdateConditionalForwarderAsync(const UpdateConditionalForwarderRequestT& request,
                                       const UpdateConditionalForwarderResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::UpdateConditionalForwarder, request, handler, context);
  }
 
  virtual Model::UpdateDirectorySetupOutcome UpdateDirectorySetup(const Model::UpdateDirectorySetupRequest& request) const;
 
  template <typename UpdateDirectorySetupRequestT = Model::UpdateDirectorySetupRequest>
  Model::UpdateDirectorySetupOutcomeCallable UpdateDirectorySetupCallable(const UpdateDirectorySetupRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::UpdateDirectorySetup, request);
  }
 
  template <typename UpdateDirectorySetupRequestT = Model::UpdateDirectorySetupRequest>
  void UpdateDirectorySetupAsync(const UpdateDirectorySetupRequestT& request, const UpdateDirectorySetupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::UpdateDirectorySetup, request, handler, context);
  }
 
  virtual Model::UpdateHybridADOutcome UpdateHybridAD(const Model::UpdateHybridADRequest& request) const;
 
  template <typename UpdateHybridADRequestT = Model::UpdateHybridADRequest>
  Model::UpdateHybridADOutcomeCallable UpdateHybridADCallable(const UpdateHybridADRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::UpdateHybridAD, request);
  }
 
  template <typename UpdateHybridADRequestT = Model::UpdateHybridADRequest>
  void UpdateHybridADAsync(const UpdateHybridADRequestT& request, const UpdateHybridADResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::UpdateHybridAD, request, handler, context);
  }
 
  virtual Model::UpdateNumberOfDomainControllersOutcome UpdateNumberOfDomainControllers(
      const Model::UpdateNumberOfDomainControllersRequest& request) const;
 
  template <typename UpdateNumberOfDomainControllersRequestT = Model::UpdateNumberOfDomainControllersRequest>
  Model::UpdateNumberOfDomainControllersOutcomeCallable UpdateNumberOfDomainControllersCallable(
      const UpdateNumberOfDomainControllersRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::UpdateNumberOfDomainControllers, request);
  }
 
  template <typename UpdateNumberOfDomainControllersRequestT = Model::UpdateNumberOfDomainControllersRequest>
  void UpdateNumberOfDomainControllersAsync(const UpdateNumberOfDomainControllersRequestT& request,
                                            const UpdateNumberOfDomainControllersResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::UpdateNumberOfDomainControllers, request, handler, context);
  }
 
  virtual Model::UpdateRadiusOutcome UpdateRadius(const Model::UpdateRadiusRequest& request) const;
 
  template <typename UpdateRadiusRequestT = Model::UpdateRadiusRequest>
  Model::UpdateRadiusOutcomeCallable UpdateRadiusCallable(const UpdateRadiusRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::UpdateRadius, request);
  }
 
  template <typename UpdateRadiusRequestT = Model::UpdateRadiusRequest>
  void UpdateRadiusAsync(const UpdateRadiusRequestT& request, const UpdateRadiusResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::UpdateRadius, request, handler, context);
  }
 
  virtual Model::UpdateSettingsOutcome UpdateSettings(const Model::UpdateSettingsRequest& request) const;
 
  template <typename UpdateSettingsRequestT = Model::UpdateSettingsRequest>
  Model::UpdateSettingsOutcomeCallable UpdateSettingsCallable(const UpdateSettingsRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::UpdateSettings, request);
  }
 
  template <typename UpdateSettingsRequestT = Model::UpdateSettingsRequest>
  void UpdateSettingsAsync(const UpdateSettingsRequestT& request, const UpdateSettingsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::UpdateSettings, request, handler, context);
  }
 
  virtual Model::UpdateTrustOutcome UpdateTrust(const Model::UpdateTrustRequest& request) const;
 
  template <typename UpdateTrustRequestT = Model::UpdateTrustRequest>
  Model::UpdateTrustOutcomeCallable UpdateTrustCallable(const UpdateTrustRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::UpdateTrust, request);
  }
 
  template <typename UpdateTrustRequestT = Model::UpdateTrustRequest>
  void UpdateTrustAsync(const UpdateTrustRequestT& request, const UpdateTrustResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::UpdateTrust, request, handler, context);
  }
 
  virtual Model::VerifyTrustOutcome VerifyTrust(const Model::VerifyTrustRequest& request) const;
 
  template <typename VerifyTrustRequestT = Model::VerifyTrustRequest>
  Model::VerifyTrustOutcomeCallable VerifyTrustCallable(const VerifyTrustRequestT& request) const {
    return SubmitCallable(&DirectoryServiceClient::VerifyTrust, request);
  }
 
  template <typename VerifyTrustRequestT = Model::VerifyTrustRequest>
  void VerifyTrustAsync(const VerifyTrustRequestT& request, const VerifyTrustResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectoryServiceClient::VerifyTrust, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<DirectoryServiceEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<DirectoryServiceClient>;
  void init(const DirectoryServiceClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, DirectoryServiceError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  DirectoryServiceClientConfiguration m_clientConfiguration;
  std::shared_ptr<DirectoryServiceEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace DirectoryService
}  // namespace Aws