DirectoryServiceClient.h

 
#pragma once
#include <aws/ds/DirectoryService_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/ds/DirectoryServiceServiceClientModel.h>
 
namespace Aws
{
namespace DirectoryService
{
  class AWS_DIRECTORYSERVICE_API DirectoryServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<DirectoryServiceEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<DirectoryServiceClient>;
      void init(const DirectoryServiceClientConfiguration& clientConfiguration);
 
      DirectoryServiceClientConfiguration m_clientConfiguration;
      std::shared_ptr<DirectoryServiceEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace DirectoryService
} // namespace Aws