SSMClient.h

 
#pragma once
#include <aws/ssm/SSM_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/ssm/SSMServiceClientModel.h>
 
namespace Aws
{
namespace SSM
{
  class AWS_SSM_API SSMClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<SSMClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SSMClientConfiguration ClientConfigurationType;
      typedef SSMEndpointProvider EndpointProviderType;
 
        SSMClient(const Aws::SSM::SSMClientConfiguration& clientConfiguration = Aws::SSM::SSMClientConfiguration(),
                  std::shared_ptr<SSMEndpointProviderBase> endpointProvider = nullptr);
 
        SSMClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<SSMEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::SSM::SSMClientConfiguration& clientConfiguration = Aws::SSM::SSMClientConfiguration());
 
        SSMClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<SSMEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::SSM::SSMClientConfiguration& clientConfiguration = Aws::SSM::SSMClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SSMClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SSMClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SSMClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SSMClient();
 
        virtual Model::AddTagsToResourceOutcome AddTagsToResource(const Model::AddTagsToResourceRequest& request) const;
 
        template<typename AddTagsToResourceRequestT = Model::AddTagsToResourceRequest>
        Model::AddTagsToResourceOutcomeCallable AddTagsToResourceCallable(const AddTagsToResourceRequestT& request) const
        {
            return SubmitCallable(&SSMClient::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(&SSMClient::AddTagsToResource, request, handler, context);
        }
 
        virtual Model::AssociateOpsItemRelatedItemOutcome AssociateOpsItemRelatedItem(const Model::AssociateOpsItemRelatedItemRequest& request) const;
 
        template<typename AssociateOpsItemRelatedItemRequestT = Model::AssociateOpsItemRelatedItemRequest>
        Model::AssociateOpsItemRelatedItemOutcomeCallable AssociateOpsItemRelatedItemCallable(const AssociateOpsItemRelatedItemRequestT& request) const
        {
            return SubmitCallable(&SSMClient::AssociateOpsItemRelatedItem, request);
        }
 
        template<typename AssociateOpsItemRelatedItemRequestT = Model::AssociateOpsItemRelatedItemRequest>
        void AssociateOpsItemRelatedItemAsync(const AssociateOpsItemRelatedItemRequestT& request, const AssociateOpsItemRelatedItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::AssociateOpsItemRelatedItem, request, handler, context);
        }
 
        virtual Model::CancelCommandOutcome CancelCommand(const Model::CancelCommandRequest& request) const;
 
        template<typename CancelCommandRequestT = Model::CancelCommandRequest>
        Model::CancelCommandOutcomeCallable CancelCommandCallable(const CancelCommandRequestT& request) const
        {
            return SubmitCallable(&SSMClient::CancelCommand, request);
        }
 
        template<typename CancelCommandRequestT = Model::CancelCommandRequest>
        void CancelCommandAsync(const CancelCommandRequestT& request, const CancelCommandResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::CancelCommand, request, handler, context);
        }
 
        virtual Model::CancelMaintenanceWindowExecutionOutcome CancelMaintenanceWindowExecution(const Model::CancelMaintenanceWindowExecutionRequest& request) const;
 
        template<typename CancelMaintenanceWindowExecutionRequestT = Model::CancelMaintenanceWindowExecutionRequest>
        Model::CancelMaintenanceWindowExecutionOutcomeCallable CancelMaintenanceWindowExecutionCallable(const CancelMaintenanceWindowExecutionRequestT& request) const
        {
            return SubmitCallable(&SSMClient::CancelMaintenanceWindowExecution, request);
        }
 
        template<typename CancelMaintenanceWindowExecutionRequestT = Model::CancelMaintenanceWindowExecutionRequest>
        void CancelMaintenanceWindowExecutionAsync(const CancelMaintenanceWindowExecutionRequestT& request, const CancelMaintenanceWindowExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::CancelMaintenanceWindowExecution, request, handler, context);
        }
 
        virtual Model::CreateActivationOutcome CreateActivation(const Model::CreateActivationRequest& request) const;
 
        template<typename CreateActivationRequestT = Model::CreateActivationRequest>
        Model::CreateActivationOutcomeCallable CreateActivationCallable(const CreateActivationRequestT& request) const
        {
            return SubmitCallable(&SSMClient::CreateActivation, request);
        }
 
        template<typename CreateActivationRequestT = Model::CreateActivationRequest>
        void CreateActivationAsync(const CreateActivationRequestT& request, const CreateActivationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::CreateActivation, request, handler, context);
        }
 
        virtual Model::CreateAssociationOutcome CreateAssociation(const Model::CreateAssociationRequest& request) const;
 
        template<typename CreateAssociationRequestT = Model::CreateAssociationRequest>
        Model::CreateAssociationOutcomeCallable CreateAssociationCallable(const CreateAssociationRequestT& request) const
        {
            return SubmitCallable(&SSMClient::CreateAssociation, request);
        }
 
        template<typename CreateAssociationRequestT = Model::CreateAssociationRequest>
        void CreateAssociationAsync(const CreateAssociationRequestT& request, const CreateAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::CreateAssociation, request, handler, context);
        }
 
        virtual Model::CreateAssociationBatchOutcome CreateAssociationBatch(const Model::CreateAssociationBatchRequest& request) const;
 
        template<typename CreateAssociationBatchRequestT = Model::CreateAssociationBatchRequest>
        Model::CreateAssociationBatchOutcomeCallable CreateAssociationBatchCallable(const CreateAssociationBatchRequestT& request) const
        {
            return SubmitCallable(&SSMClient::CreateAssociationBatch, request);
        }
 
        template<typename CreateAssociationBatchRequestT = Model::CreateAssociationBatchRequest>
        void CreateAssociationBatchAsync(const CreateAssociationBatchRequestT& request, const CreateAssociationBatchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::CreateAssociationBatch, request, handler, context);
        }
 
        virtual Model::CreateDocumentOutcome CreateDocument(const Model::CreateDocumentRequest& request) const;
 
        template<typename CreateDocumentRequestT = Model::CreateDocumentRequest>
        Model::CreateDocumentOutcomeCallable CreateDocumentCallable(const CreateDocumentRequestT& request) const
        {
            return SubmitCallable(&SSMClient::CreateDocument, request);
        }
 
        template<typename CreateDocumentRequestT = Model::CreateDocumentRequest>
        void CreateDocumentAsync(const CreateDocumentRequestT& request, const CreateDocumentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::CreateDocument, request, handler, context);
        }
 
        virtual Model::CreateMaintenanceWindowOutcome CreateMaintenanceWindow(const Model::CreateMaintenanceWindowRequest& request) const;
 
        template<typename CreateMaintenanceWindowRequestT = Model::CreateMaintenanceWindowRequest>
        Model::CreateMaintenanceWindowOutcomeCallable CreateMaintenanceWindowCallable(const CreateMaintenanceWindowRequestT& request) const
        {
            return SubmitCallable(&SSMClient::CreateMaintenanceWindow, request);
        }
 
        template<typename CreateMaintenanceWindowRequestT = Model::CreateMaintenanceWindowRequest>
        void CreateMaintenanceWindowAsync(const CreateMaintenanceWindowRequestT& request, const CreateMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::CreateMaintenanceWindow, request, handler, context);
        }
 
        virtual Model::CreateOpsItemOutcome CreateOpsItem(const Model::CreateOpsItemRequest& request) const;
 
        template<typename CreateOpsItemRequestT = Model::CreateOpsItemRequest>
        Model::CreateOpsItemOutcomeCallable CreateOpsItemCallable(const CreateOpsItemRequestT& request) const
        {
            return SubmitCallable(&SSMClient::CreateOpsItem, request);
        }
 
        template<typename CreateOpsItemRequestT = Model::CreateOpsItemRequest>
        void CreateOpsItemAsync(const CreateOpsItemRequestT& request, const CreateOpsItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::CreateOpsItem, request, handler, context);
        }
 
        virtual Model::CreateOpsMetadataOutcome CreateOpsMetadata(const Model::CreateOpsMetadataRequest& request) const;
 
        template<typename CreateOpsMetadataRequestT = Model::CreateOpsMetadataRequest>
        Model::CreateOpsMetadataOutcomeCallable CreateOpsMetadataCallable(const CreateOpsMetadataRequestT& request) const
        {
            return SubmitCallable(&SSMClient::CreateOpsMetadata, request);
        }
 
        template<typename CreateOpsMetadataRequestT = Model::CreateOpsMetadataRequest>
        void CreateOpsMetadataAsync(const CreateOpsMetadataRequestT& request, const CreateOpsMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::CreateOpsMetadata, request, handler, context);
        }
 
        virtual Model::CreatePatchBaselineOutcome CreatePatchBaseline(const Model::CreatePatchBaselineRequest& request) const;
 
        template<typename CreatePatchBaselineRequestT = Model::CreatePatchBaselineRequest>
        Model::CreatePatchBaselineOutcomeCallable CreatePatchBaselineCallable(const CreatePatchBaselineRequestT& request) const
        {
            return SubmitCallable(&SSMClient::CreatePatchBaseline, request);
        }
 
        template<typename CreatePatchBaselineRequestT = Model::CreatePatchBaselineRequest>
        void CreatePatchBaselineAsync(const CreatePatchBaselineRequestT& request, const CreatePatchBaselineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::CreatePatchBaseline, request, handler, context);
        }
 
        virtual Model::CreateResourceDataSyncOutcome CreateResourceDataSync(const Model::CreateResourceDataSyncRequest& request) const;
 
        template<typename CreateResourceDataSyncRequestT = Model::CreateResourceDataSyncRequest>
        Model::CreateResourceDataSyncOutcomeCallable CreateResourceDataSyncCallable(const CreateResourceDataSyncRequestT& request) const
        {
            return SubmitCallable(&SSMClient::CreateResourceDataSync, request);
        }
 
        template<typename CreateResourceDataSyncRequestT = Model::CreateResourceDataSyncRequest>
        void CreateResourceDataSyncAsync(const CreateResourceDataSyncRequestT& request, const CreateResourceDataSyncResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::CreateResourceDataSync, request, handler, context);
        }
 
        virtual Model::DeleteActivationOutcome DeleteActivation(const Model::DeleteActivationRequest& request) const;
 
        template<typename DeleteActivationRequestT = Model::DeleteActivationRequest>
        Model::DeleteActivationOutcomeCallable DeleteActivationCallable(const DeleteActivationRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DeleteActivation, request);
        }
 
        template<typename DeleteActivationRequestT = Model::DeleteActivationRequest>
        void DeleteActivationAsync(const DeleteActivationRequestT& request, const DeleteActivationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DeleteActivation, request, handler, context);
        }
 
        virtual Model::DeleteAssociationOutcome DeleteAssociation(const Model::DeleteAssociationRequest& request = {}) const;
 
        template<typename DeleteAssociationRequestT = Model::DeleteAssociationRequest>
        Model::DeleteAssociationOutcomeCallable DeleteAssociationCallable(const DeleteAssociationRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::DeleteAssociation, request);
        }
 
        template<typename DeleteAssociationRequestT = Model::DeleteAssociationRequest>
        void DeleteAssociationAsync(const DeleteAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteAssociationRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::DeleteAssociation, request, handler, context);
        }
 
        virtual Model::DeleteDocumentOutcome DeleteDocument(const Model::DeleteDocumentRequest& request) const;
 
        template<typename DeleteDocumentRequestT = Model::DeleteDocumentRequest>
        Model::DeleteDocumentOutcomeCallable DeleteDocumentCallable(const DeleteDocumentRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DeleteDocument, request);
        }
 
        template<typename DeleteDocumentRequestT = Model::DeleteDocumentRequest>
        void DeleteDocumentAsync(const DeleteDocumentRequestT& request, const DeleteDocumentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DeleteDocument, request, handler, context);
        }
 
        virtual Model::DeleteInventoryOutcome DeleteInventory(const Model::DeleteInventoryRequest& request) const;
 
        template<typename DeleteInventoryRequestT = Model::DeleteInventoryRequest>
        Model::DeleteInventoryOutcomeCallable DeleteInventoryCallable(const DeleteInventoryRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DeleteInventory, request);
        }
 
        template<typename DeleteInventoryRequestT = Model::DeleteInventoryRequest>
        void DeleteInventoryAsync(const DeleteInventoryRequestT& request, const DeleteInventoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DeleteInventory, request, handler, context);
        }
 
        virtual Model::DeleteMaintenanceWindowOutcome DeleteMaintenanceWindow(const Model::DeleteMaintenanceWindowRequest& request) const;
 
        template<typename DeleteMaintenanceWindowRequestT = Model::DeleteMaintenanceWindowRequest>
        Model::DeleteMaintenanceWindowOutcomeCallable DeleteMaintenanceWindowCallable(const DeleteMaintenanceWindowRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DeleteMaintenanceWindow, request);
        }
 
        template<typename DeleteMaintenanceWindowRequestT = Model::DeleteMaintenanceWindowRequest>
        void DeleteMaintenanceWindowAsync(const DeleteMaintenanceWindowRequestT& request, const DeleteMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DeleteMaintenanceWindow, request, handler, context);
        }
 
        virtual Model::DeleteOpsItemOutcome DeleteOpsItem(const Model::DeleteOpsItemRequest& request) const;
 
        template<typename DeleteOpsItemRequestT = Model::DeleteOpsItemRequest>
        Model::DeleteOpsItemOutcomeCallable DeleteOpsItemCallable(const DeleteOpsItemRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DeleteOpsItem, request);
        }
 
        template<typename DeleteOpsItemRequestT = Model::DeleteOpsItemRequest>
        void DeleteOpsItemAsync(const DeleteOpsItemRequestT& request, const DeleteOpsItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DeleteOpsItem, request, handler, context);
        }
 
        virtual Model::DeleteOpsMetadataOutcome DeleteOpsMetadata(const Model::DeleteOpsMetadataRequest& request) const;
 
        template<typename DeleteOpsMetadataRequestT = Model::DeleteOpsMetadataRequest>
        Model::DeleteOpsMetadataOutcomeCallable DeleteOpsMetadataCallable(const DeleteOpsMetadataRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DeleteOpsMetadata, request);
        }
 
        template<typename DeleteOpsMetadataRequestT = Model::DeleteOpsMetadataRequest>
        void DeleteOpsMetadataAsync(const DeleteOpsMetadataRequestT& request, const DeleteOpsMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DeleteOpsMetadata, request, handler, context);
        }
 
        virtual Model::DeleteParameterOutcome DeleteParameter(const Model::DeleteParameterRequest& request) const;
 
        template<typename DeleteParameterRequestT = Model::DeleteParameterRequest>
        Model::DeleteParameterOutcomeCallable DeleteParameterCallable(const DeleteParameterRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DeleteParameter, request);
        }
 
        template<typename DeleteParameterRequestT = Model::DeleteParameterRequest>
        void DeleteParameterAsync(const DeleteParameterRequestT& request, const DeleteParameterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DeleteParameter, request, handler, context);
        }
 
        virtual Model::DeleteParametersOutcome DeleteParameters(const Model::DeleteParametersRequest& request) const;
 
        template<typename DeleteParametersRequestT = Model::DeleteParametersRequest>
        Model::DeleteParametersOutcomeCallable DeleteParametersCallable(const DeleteParametersRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DeleteParameters, request);
        }
 
        template<typename DeleteParametersRequestT = Model::DeleteParametersRequest>
        void DeleteParametersAsync(const DeleteParametersRequestT& request, const DeleteParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DeleteParameters, request, handler, context);
        }
 
        virtual Model::DeletePatchBaselineOutcome DeletePatchBaseline(const Model::DeletePatchBaselineRequest& request) const;
 
        template<typename DeletePatchBaselineRequestT = Model::DeletePatchBaselineRequest>
        Model::DeletePatchBaselineOutcomeCallable DeletePatchBaselineCallable(const DeletePatchBaselineRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DeletePatchBaseline, request);
        }
 
        template<typename DeletePatchBaselineRequestT = Model::DeletePatchBaselineRequest>
        void DeletePatchBaselineAsync(const DeletePatchBaselineRequestT& request, const DeletePatchBaselineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DeletePatchBaseline, request, handler, context);
        }
 
        virtual Model::DeleteResourceDataSyncOutcome DeleteResourceDataSync(const Model::DeleteResourceDataSyncRequest& request) const;
 
        template<typename DeleteResourceDataSyncRequestT = Model::DeleteResourceDataSyncRequest>
        Model::DeleteResourceDataSyncOutcomeCallable DeleteResourceDataSyncCallable(const DeleteResourceDataSyncRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DeleteResourceDataSync, request);
        }
 
        template<typename DeleteResourceDataSyncRequestT = Model::DeleteResourceDataSyncRequest>
        void DeleteResourceDataSyncAsync(const DeleteResourceDataSyncRequestT& request, const DeleteResourceDataSyncResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DeleteResourceDataSync, request, handler, context);
        }
 
        virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DeleteResourcePolicy, request);
        }
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DeleteResourcePolicy, request, handler, context);
        }
 
        virtual Model::DeregisterManagedInstanceOutcome DeregisterManagedInstance(const Model::DeregisterManagedInstanceRequest& request) const;
 
        template<typename DeregisterManagedInstanceRequestT = Model::DeregisterManagedInstanceRequest>
        Model::DeregisterManagedInstanceOutcomeCallable DeregisterManagedInstanceCallable(const DeregisterManagedInstanceRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DeregisterManagedInstance, request);
        }
 
        template<typename DeregisterManagedInstanceRequestT = Model::DeregisterManagedInstanceRequest>
        void DeregisterManagedInstanceAsync(const DeregisterManagedInstanceRequestT& request, const DeregisterManagedInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DeregisterManagedInstance, request, handler, context);
        }
 
        virtual Model::DeregisterPatchBaselineForPatchGroupOutcome DeregisterPatchBaselineForPatchGroup(const Model::DeregisterPatchBaselineForPatchGroupRequest& request) const;
 
        template<typename DeregisterPatchBaselineForPatchGroupRequestT = Model::DeregisterPatchBaselineForPatchGroupRequest>
        Model::DeregisterPatchBaselineForPatchGroupOutcomeCallable DeregisterPatchBaselineForPatchGroupCallable(const DeregisterPatchBaselineForPatchGroupRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DeregisterPatchBaselineForPatchGroup, request);
        }
 
        template<typename DeregisterPatchBaselineForPatchGroupRequestT = Model::DeregisterPatchBaselineForPatchGroupRequest>
        void DeregisterPatchBaselineForPatchGroupAsync(const DeregisterPatchBaselineForPatchGroupRequestT& request, const DeregisterPatchBaselineForPatchGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DeregisterPatchBaselineForPatchGroup, request, handler, context);
        }
 
        virtual Model::DeregisterTargetFromMaintenanceWindowOutcome DeregisterTargetFromMaintenanceWindow(const Model::DeregisterTargetFromMaintenanceWindowRequest& request) const;
 
        template<typename DeregisterTargetFromMaintenanceWindowRequestT = Model::DeregisterTargetFromMaintenanceWindowRequest>
        Model::DeregisterTargetFromMaintenanceWindowOutcomeCallable DeregisterTargetFromMaintenanceWindowCallable(const DeregisterTargetFromMaintenanceWindowRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DeregisterTargetFromMaintenanceWindow, request);
        }
 
        template<typename DeregisterTargetFromMaintenanceWindowRequestT = Model::DeregisterTargetFromMaintenanceWindowRequest>
        void DeregisterTargetFromMaintenanceWindowAsync(const DeregisterTargetFromMaintenanceWindowRequestT& request, const DeregisterTargetFromMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DeregisterTargetFromMaintenanceWindow, request, handler, context);
        }
 
        virtual Model::DeregisterTaskFromMaintenanceWindowOutcome DeregisterTaskFromMaintenanceWindow(const Model::DeregisterTaskFromMaintenanceWindowRequest& request) const;
 
        template<typename DeregisterTaskFromMaintenanceWindowRequestT = Model::DeregisterTaskFromMaintenanceWindowRequest>
        Model::DeregisterTaskFromMaintenanceWindowOutcomeCallable DeregisterTaskFromMaintenanceWindowCallable(const DeregisterTaskFromMaintenanceWindowRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DeregisterTaskFromMaintenanceWindow, request);
        }
 
        template<typename DeregisterTaskFromMaintenanceWindowRequestT = Model::DeregisterTaskFromMaintenanceWindowRequest>
        void DeregisterTaskFromMaintenanceWindowAsync(const DeregisterTaskFromMaintenanceWindowRequestT& request, const DeregisterTaskFromMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DeregisterTaskFromMaintenanceWindow, request, handler, context);
        }
 
        virtual Model::DescribeActivationsOutcome DescribeActivations(const Model::DescribeActivationsRequest& request = {}) const;
 
        template<typename DescribeActivationsRequestT = Model::DescribeActivationsRequest>
        Model::DescribeActivationsOutcomeCallable DescribeActivationsCallable(const DescribeActivationsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::DescribeActivations, request);
        }
 
        template<typename DescribeActivationsRequestT = Model::DescribeActivationsRequest>
        void DescribeActivationsAsync(const DescribeActivationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeActivationsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::DescribeActivations, request, handler, context);
        }
 
        virtual Model::DescribeAssociationOutcome DescribeAssociation(const Model::DescribeAssociationRequest& request = {}) const;
 
        template<typename DescribeAssociationRequestT = Model::DescribeAssociationRequest>
        Model::DescribeAssociationOutcomeCallable DescribeAssociationCallable(const DescribeAssociationRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::DescribeAssociation, request);
        }
 
        template<typename DescribeAssociationRequestT = Model::DescribeAssociationRequest>
        void DescribeAssociationAsync(const DescribeAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAssociationRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::DescribeAssociation, request, handler, context);
        }
 
        virtual Model::DescribeAssociationExecutionTargetsOutcome DescribeAssociationExecutionTargets(const Model::DescribeAssociationExecutionTargetsRequest& request) const;
 
        template<typename DescribeAssociationExecutionTargetsRequestT = Model::DescribeAssociationExecutionTargetsRequest>
        Model::DescribeAssociationExecutionTargetsOutcomeCallable DescribeAssociationExecutionTargetsCallable(const DescribeAssociationExecutionTargetsRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeAssociationExecutionTargets, request);
        }
 
        template<typename DescribeAssociationExecutionTargetsRequestT = Model::DescribeAssociationExecutionTargetsRequest>
        void DescribeAssociationExecutionTargetsAsync(const DescribeAssociationExecutionTargetsRequestT& request, const DescribeAssociationExecutionTargetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeAssociationExecutionTargets, request, handler, context);
        }
 
        virtual Model::DescribeAssociationExecutionsOutcome DescribeAssociationExecutions(const Model::DescribeAssociationExecutionsRequest& request) const;
 
        template<typename DescribeAssociationExecutionsRequestT = Model::DescribeAssociationExecutionsRequest>
        Model::DescribeAssociationExecutionsOutcomeCallable DescribeAssociationExecutionsCallable(const DescribeAssociationExecutionsRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeAssociationExecutions, request);
        }
 
        template<typename DescribeAssociationExecutionsRequestT = Model::DescribeAssociationExecutionsRequest>
        void DescribeAssociationExecutionsAsync(const DescribeAssociationExecutionsRequestT& request, const DescribeAssociationExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeAssociationExecutions, request, handler, context);
        }
 
        virtual Model::DescribeAutomationExecutionsOutcome DescribeAutomationExecutions(const Model::DescribeAutomationExecutionsRequest& request = {}) const;
 
        template<typename DescribeAutomationExecutionsRequestT = Model::DescribeAutomationExecutionsRequest>
        Model::DescribeAutomationExecutionsOutcomeCallable DescribeAutomationExecutionsCallable(const DescribeAutomationExecutionsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::DescribeAutomationExecutions, request);
        }
 
        template<typename DescribeAutomationExecutionsRequestT = Model::DescribeAutomationExecutionsRequest>
        void DescribeAutomationExecutionsAsync(const DescribeAutomationExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAutomationExecutionsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::DescribeAutomationExecutions, request, handler, context);
        }
 
        virtual Model::DescribeAutomationStepExecutionsOutcome DescribeAutomationStepExecutions(const Model::DescribeAutomationStepExecutionsRequest& request) const;
 
        template<typename DescribeAutomationStepExecutionsRequestT = Model::DescribeAutomationStepExecutionsRequest>
        Model::DescribeAutomationStepExecutionsOutcomeCallable DescribeAutomationStepExecutionsCallable(const DescribeAutomationStepExecutionsRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeAutomationStepExecutions, request);
        }
 
        template<typename DescribeAutomationStepExecutionsRequestT = Model::DescribeAutomationStepExecutionsRequest>
        void DescribeAutomationStepExecutionsAsync(const DescribeAutomationStepExecutionsRequestT& request, const DescribeAutomationStepExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeAutomationStepExecutions, request, handler, context);
        }
 
        virtual Model::DescribeAvailablePatchesOutcome DescribeAvailablePatches(const Model::DescribeAvailablePatchesRequest& request = {}) const;
 
        template<typename DescribeAvailablePatchesRequestT = Model::DescribeAvailablePatchesRequest>
        Model::DescribeAvailablePatchesOutcomeCallable DescribeAvailablePatchesCallable(const DescribeAvailablePatchesRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::DescribeAvailablePatches, request);
        }
 
        template<typename DescribeAvailablePatchesRequestT = Model::DescribeAvailablePatchesRequest>
        void DescribeAvailablePatchesAsync(const DescribeAvailablePatchesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAvailablePatchesRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::DescribeAvailablePatches, request, handler, context);
        }
 
        virtual Model::DescribeDocumentOutcome DescribeDocument(const Model::DescribeDocumentRequest& request) const;
 
        template<typename DescribeDocumentRequestT = Model::DescribeDocumentRequest>
        Model::DescribeDocumentOutcomeCallable DescribeDocumentCallable(const DescribeDocumentRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeDocument, request);
        }
 
        template<typename DescribeDocumentRequestT = Model::DescribeDocumentRequest>
        void DescribeDocumentAsync(const DescribeDocumentRequestT& request, const DescribeDocumentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeDocument, request, handler, context);
        }
 
        virtual Model::DescribeDocumentPermissionOutcome DescribeDocumentPermission(const Model::DescribeDocumentPermissionRequest& request) const;
 
        template<typename DescribeDocumentPermissionRequestT = Model::DescribeDocumentPermissionRequest>
        Model::DescribeDocumentPermissionOutcomeCallable DescribeDocumentPermissionCallable(const DescribeDocumentPermissionRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeDocumentPermission, request);
        }
 
        template<typename DescribeDocumentPermissionRequestT = Model::DescribeDocumentPermissionRequest>
        void DescribeDocumentPermissionAsync(const DescribeDocumentPermissionRequestT& request, const DescribeDocumentPermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeDocumentPermission, request, handler, context);
        }
 
        virtual Model::DescribeEffectiveInstanceAssociationsOutcome DescribeEffectiveInstanceAssociations(const Model::DescribeEffectiveInstanceAssociationsRequest& request) const;
 
        template<typename DescribeEffectiveInstanceAssociationsRequestT = Model::DescribeEffectiveInstanceAssociationsRequest>
        Model::DescribeEffectiveInstanceAssociationsOutcomeCallable DescribeEffectiveInstanceAssociationsCallable(const DescribeEffectiveInstanceAssociationsRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeEffectiveInstanceAssociations, request);
        }
 
        template<typename DescribeEffectiveInstanceAssociationsRequestT = Model::DescribeEffectiveInstanceAssociationsRequest>
        void DescribeEffectiveInstanceAssociationsAsync(const DescribeEffectiveInstanceAssociationsRequestT& request, const DescribeEffectiveInstanceAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeEffectiveInstanceAssociations, request, handler, context);
        }
 
        virtual Model::DescribeEffectivePatchesForPatchBaselineOutcome DescribeEffectivePatchesForPatchBaseline(const Model::DescribeEffectivePatchesForPatchBaselineRequest& request) const;
 
        template<typename DescribeEffectivePatchesForPatchBaselineRequestT = Model::DescribeEffectivePatchesForPatchBaselineRequest>
        Model::DescribeEffectivePatchesForPatchBaselineOutcomeCallable DescribeEffectivePatchesForPatchBaselineCallable(const DescribeEffectivePatchesForPatchBaselineRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeEffectivePatchesForPatchBaseline, request);
        }
 
        template<typename DescribeEffectivePatchesForPatchBaselineRequestT = Model::DescribeEffectivePatchesForPatchBaselineRequest>
        void DescribeEffectivePatchesForPatchBaselineAsync(const DescribeEffectivePatchesForPatchBaselineRequestT& request, const DescribeEffectivePatchesForPatchBaselineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeEffectivePatchesForPatchBaseline, request, handler, context);
        }
 
        virtual Model::DescribeInstanceAssociationsStatusOutcome DescribeInstanceAssociationsStatus(const Model::DescribeInstanceAssociationsStatusRequest& request) const;
 
        template<typename DescribeInstanceAssociationsStatusRequestT = Model::DescribeInstanceAssociationsStatusRequest>
        Model::DescribeInstanceAssociationsStatusOutcomeCallable DescribeInstanceAssociationsStatusCallable(const DescribeInstanceAssociationsStatusRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeInstanceAssociationsStatus, request);
        }
 
        template<typename DescribeInstanceAssociationsStatusRequestT = Model::DescribeInstanceAssociationsStatusRequest>
        void DescribeInstanceAssociationsStatusAsync(const DescribeInstanceAssociationsStatusRequestT& request, const DescribeInstanceAssociationsStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeInstanceAssociationsStatus, request, handler, context);
        }
 
        virtual Model::DescribeInstanceInformationOutcome DescribeInstanceInformation(const Model::DescribeInstanceInformationRequest& request = {}) const;
 
        template<typename DescribeInstanceInformationRequestT = Model::DescribeInstanceInformationRequest>
        Model::DescribeInstanceInformationOutcomeCallable DescribeInstanceInformationCallable(const DescribeInstanceInformationRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::DescribeInstanceInformation, request);
        }
 
        template<typename DescribeInstanceInformationRequestT = Model::DescribeInstanceInformationRequest>
        void DescribeInstanceInformationAsync(const DescribeInstanceInformationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeInstanceInformationRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::DescribeInstanceInformation, request, handler, context);
        }
 
        virtual Model::DescribeInstancePatchStatesOutcome DescribeInstancePatchStates(const Model::DescribeInstancePatchStatesRequest& request) const;
 
        template<typename DescribeInstancePatchStatesRequestT = Model::DescribeInstancePatchStatesRequest>
        Model::DescribeInstancePatchStatesOutcomeCallable DescribeInstancePatchStatesCallable(const DescribeInstancePatchStatesRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeInstancePatchStates, request);
        }
 
        template<typename DescribeInstancePatchStatesRequestT = Model::DescribeInstancePatchStatesRequest>
        void DescribeInstancePatchStatesAsync(const DescribeInstancePatchStatesRequestT& request, const DescribeInstancePatchStatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeInstancePatchStates, request, handler, context);
        }
 
        virtual Model::DescribeInstancePatchStatesForPatchGroupOutcome DescribeInstancePatchStatesForPatchGroup(const Model::DescribeInstancePatchStatesForPatchGroupRequest& request) const;
 
        template<typename DescribeInstancePatchStatesForPatchGroupRequestT = Model::DescribeInstancePatchStatesForPatchGroupRequest>
        Model::DescribeInstancePatchStatesForPatchGroupOutcomeCallable DescribeInstancePatchStatesForPatchGroupCallable(const DescribeInstancePatchStatesForPatchGroupRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeInstancePatchStatesForPatchGroup, request);
        }
 
        template<typename DescribeInstancePatchStatesForPatchGroupRequestT = Model::DescribeInstancePatchStatesForPatchGroupRequest>
        void DescribeInstancePatchStatesForPatchGroupAsync(const DescribeInstancePatchStatesForPatchGroupRequestT& request, const DescribeInstancePatchStatesForPatchGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeInstancePatchStatesForPatchGroup, request, handler, context);
        }
 
        virtual Model::DescribeInstancePatchesOutcome DescribeInstancePatches(const Model::DescribeInstancePatchesRequest& request) const;
 
        template<typename DescribeInstancePatchesRequestT = Model::DescribeInstancePatchesRequest>
        Model::DescribeInstancePatchesOutcomeCallable DescribeInstancePatchesCallable(const DescribeInstancePatchesRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeInstancePatches, request);
        }
 
        template<typename DescribeInstancePatchesRequestT = Model::DescribeInstancePatchesRequest>
        void DescribeInstancePatchesAsync(const DescribeInstancePatchesRequestT& request, const DescribeInstancePatchesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeInstancePatches, request, handler, context);
        }
 
        virtual Model::DescribeInstancePropertiesOutcome DescribeInstanceProperties(const Model::DescribeInstancePropertiesRequest& request = {}) const;
 
        template<typename DescribeInstancePropertiesRequestT = Model::DescribeInstancePropertiesRequest>
        Model::DescribeInstancePropertiesOutcomeCallable DescribeInstancePropertiesCallable(const DescribeInstancePropertiesRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::DescribeInstanceProperties, request);
        }
 
        template<typename DescribeInstancePropertiesRequestT = Model::DescribeInstancePropertiesRequest>
        void DescribeInstancePropertiesAsync(const DescribeInstancePropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeInstancePropertiesRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::DescribeInstanceProperties, request, handler, context);
        }
 
        virtual Model::DescribeInventoryDeletionsOutcome DescribeInventoryDeletions(const Model::DescribeInventoryDeletionsRequest& request = {}) const;
 
        template<typename DescribeInventoryDeletionsRequestT = Model::DescribeInventoryDeletionsRequest>
        Model::DescribeInventoryDeletionsOutcomeCallable DescribeInventoryDeletionsCallable(const DescribeInventoryDeletionsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::DescribeInventoryDeletions, request);
        }
 
        template<typename DescribeInventoryDeletionsRequestT = Model::DescribeInventoryDeletionsRequest>
        void DescribeInventoryDeletionsAsync(const DescribeInventoryDeletionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeInventoryDeletionsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::DescribeInventoryDeletions, request, handler, context);
        }
 
        virtual Model::DescribeMaintenanceWindowExecutionTaskInvocationsOutcome DescribeMaintenanceWindowExecutionTaskInvocations(const Model::DescribeMaintenanceWindowExecutionTaskInvocationsRequest& request) const;
 
        template<typename DescribeMaintenanceWindowExecutionTaskInvocationsRequestT = Model::DescribeMaintenanceWindowExecutionTaskInvocationsRequest>
        Model::DescribeMaintenanceWindowExecutionTaskInvocationsOutcomeCallable DescribeMaintenanceWindowExecutionTaskInvocationsCallable(const DescribeMaintenanceWindowExecutionTaskInvocationsRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeMaintenanceWindowExecutionTaskInvocations, request);
        }
 
        template<typename DescribeMaintenanceWindowExecutionTaskInvocationsRequestT = Model::DescribeMaintenanceWindowExecutionTaskInvocationsRequest>
        void DescribeMaintenanceWindowExecutionTaskInvocationsAsync(const DescribeMaintenanceWindowExecutionTaskInvocationsRequestT& request, const DescribeMaintenanceWindowExecutionTaskInvocationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeMaintenanceWindowExecutionTaskInvocations, request, handler, context);
        }
 
        virtual Model::DescribeMaintenanceWindowExecutionTasksOutcome DescribeMaintenanceWindowExecutionTasks(const Model::DescribeMaintenanceWindowExecutionTasksRequest& request) const;
 
        template<typename DescribeMaintenanceWindowExecutionTasksRequestT = Model::DescribeMaintenanceWindowExecutionTasksRequest>
        Model::DescribeMaintenanceWindowExecutionTasksOutcomeCallable DescribeMaintenanceWindowExecutionTasksCallable(const DescribeMaintenanceWindowExecutionTasksRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeMaintenanceWindowExecutionTasks, request);
        }
 
        template<typename DescribeMaintenanceWindowExecutionTasksRequestT = Model::DescribeMaintenanceWindowExecutionTasksRequest>
        void DescribeMaintenanceWindowExecutionTasksAsync(const DescribeMaintenanceWindowExecutionTasksRequestT& request, const DescribeMaintenanceWindowExecutionTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeMaintenanceWindowExecutionTasks, request, handler, context);
        }
 
        virtual Model::DescribeMaintenanceWindowExecutionsOutcome DescribeMaintenanceWindowExecutions(const Model::DescribeMaintenanceWindowExecutionsRequest& request) const;
 
        template<typename DescribeMaintenanceWindowExecutionsRequestT = Model::DescribeMaintenanceWindowExecutionsRequest>
        Model::DescribeMaintenanceWindowExecutionsOutcomeCallable DescribeMaintenanceWindowExecutionsCallable(const DescribeMaintenanceWindowExecutionsRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeMaintenanceWindowExecutions, request);
        }
 
        template<typename DescribeMaintenanceWindowExecutionsRequestT = Model::DescribeMaintenanceWindowExecutionsRequest>
        void DescribeMaintenanceWindowExecutionsAsync(const DescribeMaintenanceWindowExecutionsRequestT& request, const DescribeMaintenanceWindowExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeMaintenanceWindowExecutions, request, handler, context);
        }
 
        virtual Model::DescribeMaintenanceWindowScheduleOutcome DescribeMaintenanceWindowSchedule(const Model::DescribeMaintenanceWindowScheduleRequest& request = {}) const;
 
        template<typename DescribeMaintenanceWindowScheduleRequestT = Model::DescribeMaintenanceWindowScheduleRequest>
        Model::DescribeMaintenanceWindowScheduleOutcomeCallable DescribeMaintenanceWindowScheduleCallable(const DescribeMaintenanceWindowScheduleRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::DescribeMaintenanceWindowSchedule, request);
        }
 
        template<typename DescribeMaintenanceWindowScheduleRequestT = Model::DescribeMaintenanceWindowScheduleRequest>
        void DescribeMaintenanceWindowScheduleAsync(const DescribeMaintenanceWindowScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeMaintenanceWindowScheduleRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::DescribeMaintenanceWindowSchedule, request, handler, context);
        }
 
        virtual Model::DescribeMaintenanceWindowTargetsOutcome DescribeMaintenanceWindowTargets(const Model::DescribeMaintenanceWindowTargetsRequest& request) const;
 
        template<typename DescribeMaintenanceWindowTargetsRequestT = Model::DescribeMaintenanceWindowTargetsRequest>
        Model::DescribeMaintenanceWindowTargetsOutcomeCallable DescribeMaintenanceWindowTargetsCallable(const DescribeMaintenanceWindowTargetsRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeMaintenanceWindowTargets, request);
        }
 
        template<typename DescribeMaintenanceWindowTargetsRequestT = Model::DescribeMaintenanceWindowTargetsRequest>
        void DescribeMaintenanceWindowTargetsAsync(const DescribeMaintenanceWindowTargetsRequestT& request, const DescribeMaintenanceWindowTargetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeMaintenanceWindowTargets, request, handler, context);
        }
 
        virtual Model::DescribeMaintenanceWindowTasksOutcome DescribeMaintenanceWindowTasks(const Model::DescribeMaintenanceWindowTasksRequest& request) const;
 
        template<typename DescribeMaintenanceWindowTasksRequestT = Model::DescribeMaintenanceWindowTasksRequest>
        Model::DescribeMaintenanceWindowTasksOutcomeCallable DescribeMaintenanceWindowTasksCallable(const DescribeMaintenanceWindowTasksRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeMaintenanceWindowTasks, request);
        }
 
        template<typename DescribeMaintenanceWindowTasksRequestT = Model::DescribeMaintenanceWindowTasksRequest>
        void DescribeMaintenanceWindowTasksAsync(const DescribeMaintenanceWindowTasksRequestT& request, const DescribeMaintenanceWindowTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeMaintenanceWindowTasks, request, handler, context);
        }
 
        virtual Model::DescribeMaintenanceWindowsOutcome DescribeMaintenanceWindows(const Model::DescribeMaintenanceWindowsRequest& request = {}) const;
 
        template<typename DescribeMaintenanceWindowsRequestT = Model::DescribeMaintenanceWindowsRequest>
        Model::DescribeMaintenanceWindowsOutcomeCallable DescribeMaintenanceWindowsCallable(const DescribeMaintenanceWindowsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::DescribeMaintenanceWindows, request);
        }
 
        template<typename DescribeMaintenanceWindowsRequestT = Model::DescribeMaintenanceWindowsRequest>
        void DescribeMaintenanceWindowsAsync(const DescribeMaintenanceWindowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeMaintenanceWindowsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::DescribeMaintenanceWindows, request, handler, context);
        }
 
        virtual Model::DescribeMaintenanceWindowsForTargetOutcome DescribeMaintenanceWindowsForTarget(const Model::DescribeMaintenanceWindowsForTargetRequest& request) const;
 
        template<typename DescribeMaintenanceWindowsForTargetRequestT = Model::DescribeMaintenanceWindowsForTargetRequest>
        Model::DescribeMaintenanceWindowsForTargetOutcomeCallable DescribeMaintenanceWindowsForTargetCallable(const DescribeMaintenanceWindowsForTargetRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeMaintenanceWindowsForTarget, request);
        }
 
        template<typename DescribeMaintenanceWindowsForTargetRequestT = Model::DescribeMaintenanceWindowsForTargetRequest>
        void DescribeMaintenanceWindowsForTargetAsync(const DescribeMaintenanceWindowsForTargetRequestT& request, const DescribeMaintenanceWindowsForTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeMaintenanceWindowsForTarget, request, handler, context);
        }
 
        virtual Model::DescribeOpsItemsOutcome DescribeOpsItems(const Model::DescribeOpsItemsRequest& request = {}) const;
 
        template<typename DescribeOpsItemsRequestT = Model::DescribeOpsItemsRequest>
        Model::DescribeOpsItemsOutcomeCallable DescribeOpsItemsCallable(const DescribeOpsItemsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::DescribeOpsItems, request);
        }
 
        template<typename DescribeOpsItemsRequestT = Model::DescribeOpsItemsRequest>
        void DescribeOpsItemsAsync(const DescribeOpsItemsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeOpsItemsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::DescribeOpsItems, request, handler, context);
        }
 
        virtual Model::DescribeParametersOutcome DescribeParameters(const Model::DescribeParametersRequest& request = {}) const;
 
        template<typename DescribeParametersRequestT = Model::DescribeParametersRequest>
        Model::DescribeParametersOutcomeCallable DescribeParametersCallable(const DescribeParametersRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::DescribeParameters, request);
        }
 
        template<typename DescribeParametersRequestT = Model::DescribeParametersRequest>
        void DescribeParametersAsync(const DescribeParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeParametersRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::DescribeParameters, request, handler, context);
        }
 
        virtual Model::DescribePatchBaselinesOutcome DescribePatchBaselines(const Model::DescribePatchBaselinesRequest& request = {}) const;
 
        template<typename DescribePatchBaselinesRequestT = Model::DescribePatchBaselinesRequest>
        Model::DescribePatchBaselinesOutcomeCallable DescribePatchBaselinesCallable(const DescribePatchBaselinesRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::DescribePatchBaselines, request);
        }
 
        template<typename DescribePatchBaselinesRequestT = Model::DescribePatchBaselinesRequest>
        void DescribePatchBaselinesAsync(const DescribePatchBaselinesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribePatchBaselinesRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::DescribePatchBaselines, request, handler, context);
        }
 
        virtual Model::DescribePatchGroupStateOutcome DescribePatchGroupState(const Model::DescribePatchGroupStateRequest& request) const;
 
        template<typename DescribePatchGroupStateRequestT = Model::DescribePatchGroupStateRequest>
        Model::DescribePatchGroupStateOutcomeCallable DescribePatchGroupStateCallable(const DescribePatchGroupStateRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribePatchGroupState, request);
        }
 
        template<typename DescribePatchGroupStateRequestT = Model::DescribePatchGroupStateRequest>
        void DescribePatchGroupStateAsync(const DescribePatchGroupStateRequestT& request, const DescribePatchGroupStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribePatchGroupState, request, handler, context);
        }
 
        virtual Model::DescribePatchGroupsOutcome DescribePatchGroups(const Model::DescribePatchGroupsRequest& request = {}) const;
 
        template<typename DescribePatchGroupsRequestT = Model::DescribePatchGroupsRequest>
        Model::DescribePatchGroupsOutcomeCallable DescribePatchGroupsCallable(const DescribePatchGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::DescribePatchGroups, request);
        }
 
        template<typename DescribePatchGroupsRequestT = Model::DescribePatchGroupsRequest>
        void DescribePatchGroupsAsync(const DescribePatchGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribePatchGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::DescribePatchGroups, request, handler, context);
        }
 
        virtual Model::DescribePatchPropertiesOutcome DescribePatchProperties(const Model::DescribePatchPropertiesRequest& request) const;
 
        template<typename DescribePatchPropertiesRequestT = Model::DescribePatchPropertiesRequest>
        Model::DescribePatchPropertiesOutcomeCallable DescribePatchPropertiesCallable(const DescribePatchPropertiesRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribePatchProperties, request);
        }
 
        template<typename DescribePatchPropertiesRequestT = Model::DescribePatchPropertiesRequest>
        void DescribePatchPropertiesAsync(const DescribePatchPropertiesRequestT& request, const DescribePatchPropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribePatchProperties, request, handler, context);
        }
 
        virtual Model::DescribeSessionsOutcome DescribeSessions(const Model::DescribeSessionsRequest& request) const;
 
        template<typename DescribeSessionsRequestT = Model::DescribeSessionsRequest>
        Model::DescribeSessionsOutcomeCallable DescribeSessionsCallable(const DescribeSessionsRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DescribeSessions, request);
        }
 
        template<typename DescribeSessionsRequestT = Model::DescribeSessionsRequest>
        void DescribeSessionsAsync(const DescribeSessionsRequestT& request, const DescribeSessionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DescribeSessions, request, handler, context);
        }
 
        virtual Model::DisassociateOpsItemRelatedItemOutcome DisassociateOpsItemRelatedItem(const Model::DisassociateOpsItemRelatedItemRequest& request) const;
 
        template<typename DisassociateOpsItemRelatedItemRequestT = Model::DisassociateOpsItemRelatedItemRequest>
        Model::DisassociateOpsItemRelatedItemOutcomeCallable DisassociateOpsItemRelatedItemCallable(const DisassociateOpsItemRelatedItemRequestT& request) const
        {
            return SubmitCallable(&SSMClient::DisassociateOpsItemRelatedItem, request);
        }
 
        template<typename DisassociateOpsItemRelatedItemRequestT = Model::DisassociateOpsItemRelatedItemRequest>
        void DisassociateOpsItemRelatedItemAsync(const DisassociateOpsItemRelatedItemRequestT& request, const DisassociateOpsItemRelatedItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::DisassociateOpsItemRelatedItem, request, handler, context);
        }
 
        virtual Model::GetAccessTokenOutcome GetAccessToken(const Model::GetAccessTokenRequest& request) const;
 
        template<typename GetAccessTokenRequestT = Model::GetAccessTokenRequest>
        Model::GetAccessTokenOutcomeCallable GetAccessTokenCallable(const GetAccessTokenRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetAccessToken, request);
        }
 
        template<typename GetAccessTokenRequestT = Model::GetAccessTokenRequest>
        void GetAccessTokenAsync(const GetAccessTokenRequestT& request, const GetAccessTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetAccessToken, request, handler, context);
        }
 
        virtual Model::GetAutomationExecutionOutcome GetAutomationExecution(const Model::GetAutomationExecutionRequest& request) const;
 
        template<typename GetAutomationExecutionRequestT = Model::GetAutomationExecutionRequest>
        Model::GetAutomationExecutionOutcomeCallable GetAutomationExecutionCallable(const GetAutomationExecutionRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetAutomationExecution, request);
        }
 
        template<typename GetAutomationExecutionRequestT = Model::GetAutomationExecutionRequest>
        void GetAutomationExecutionAsync(const GetAutomationExecutionRequestT& request, const GetAutomationExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetAutomationExecution, request, handler, context);
        }
 
        virtual Model::GetCalendarStateOutcome GetCalendarState(const Model::GetCalendarStateRequest& request) const;
 
        template<typename GetCalendarStateRequestT = Model::GetCalendarStateRequest>
        Model::GetCalendarStateOutcomeCallable GetCalendarStateCallable(const GetCalendarStateRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetCalendarState, request);
        }
 
        template<typename GetCalendarStateRequestT = Model::GetCalendarStateRequest>
        void GetCalendarStateAsync(const GetCalendarStateRequestT& request, const GetCalendarStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetCalendarState, request, handler, context);
        }
 
        virtual Model::GetCommandInvocationOutcome GetCommandInvocation(const Model::GetCommandInvocationRequest& request) const;
 
        template<typename GetCommandInvocationRequestT = Model::GetCommandInvocationRequest>
        Model::GetCommandInvocationOutcomeCallable GetCommandInvocationCallable(const GetCommandInvocationRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetCommandInvocation, request);
        }
 
        template<typename GetCommandInvocationRequestT = Model::GetCommandInvocationRequest>
        void GetCommandInvocationAsync(const GetCommandInvocationRequestT& request, const GetCommandInvocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetCommandInvocation, request, handler, context);
        }
 
        virtual Model::GetConnectionStatusOutcome GetConnectionStatus(const Model::GetConnectionStatusRequest& request) const;
 
        template<typename GetConnectionStatusRequestT = Model::GetConnectionStatusRequest>
        Model::GetConnectionStatusOutcomeCallable GetConnectionStatusCallable(const GetConnectionStatusRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetConnectionStatus, request);
        }
 
        template<typename GetConnectionStatusRequestT = Model::GetConnectionStatusRequest>
        void GetConnectionStatusAsync(const GetConnectionStatusRequestT& request, const GetConnectionStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetConnectionStatus, request, handler, context);
        }
 
        virtual Model::GetDefaultPatchBaselineOutcome GetDefaultPatchBaseline(const Model::GetDefaultPatchBaselineRequest& request = {}) const;
 
        template<typename GetDefaultPatchBaselineRequestT = Model::GetDefaultPatchBaselineRequest>
        Model::GetDefaultPatchBaselineOutcomeCallable GetDefaultPatchBaselineCallable(const GetDefaultPatchBaselineRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::GetDefaultPatchBaseline, request);
        }
 
        template<typename GetDefaultPatchBaselineRequestT = Model::GetDefaultPatchBaselineRequest>
        void GetDefaultPatchBaselineAsync(const GetDefaultPatchBaselineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDefaultPatchBaselineRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::GetDefaultPatchBaseline, request, handler, context);
        }
 
        virtual Model::GetDeployablePatchSnapshotForInstanceOutcome GetDeployablePatchSnapshotForInstance(const Model::GetDeployablePatchSnapshotForInstanceRequest& request) const;
 
        template<typename GetDeployablePatchSnapshotForInstanceRequestT = Model::GetDeployablePatchSnapshotForInstanceRequest>
        Model::GetDeployablePatchSnapshotForInstanceOutcomeCallable GetDeployablePatchSnapshotForInstanceCallable(const GetDeployablePatchSnapshotForInstanceRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetDeployablePatchSnapshotForInstance, request);
        }
 
        template<typename GetDeployablePatchSnapshotForInstanceRequestT = Model::GetDeployablePatchSnapshotForInstanceRequest>
        void GetDeployablePatchSnapshotForInstanceAsync(const GetDeployablePatchSnapshotForInstanceRequestT& request, const GetDeployablePatchSnapshotForInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetDeployablePatchSnapshotForInstance, request, handler, context);
        }
 
        virtual Model::GetDocumentOutcome GetDocument(const Model::GetDocumentRequest& request) const;
 
        template<typename GetDocumentRequestT = Model::GetDocumentRequest>
        Model::GetDocumentOutcomeCallable GetDocumentCallable(const GetDocumentRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetDocument, request);
        }
 
        template<typename GetDocumentRequestT = Model::GetDocumentRequest>
        void GetDocumentAsync(const GetDocumentRequestT& request, const GetDocumentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetDocument, request, handler, context);
        }
 
        virtual Model::GetExecutionPreviewOutcome GetExecutionPreview(const Model::GetExecutionPreviewRequest& request) const;
 
        template<typename GetExecutionPreviewRequestT = Model::GetExecutionPreviewRequest>
        Model::GetExecutionPreviewOutcomeCallable GetExecutionPreviewCallable(const GetExecutionPreviewRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetExecutionPreview, request);
        }
 
        template<typename GetExecutionPreviewRequestT = Model::GetExecutionPreviewRequest>
        void GetExecutionPreviewAsync(const GetExecutionPreviewRequestT& request, const GetExecutionPreviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetExecutionPreview, request, handler, context);
        }
 
        virtual Model::GetInventoryOutcome GetInventory(const Model::GetInventoryRequest& request = {}) const;
 
        template<typename GetInventoryRequestT = Model::GetInventoryRequest>
        Model::GetInventoryOutcomeCallable GetInventoryCallable(const GetInventoryRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::GetInventory, request);
        }
 
        template<typename GetInventoryRequestT = Model::GetInventoryRequest>
        void GetInventoryAsync(const GetInventoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetInventoryRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::GetInventory, request, handler, context);
        }
 
        virtual Model::GetInventorySchemaOutcome GetInventorySchema(const Model::GetInventorySchemaRequest& request = {}) const;
 
        template<typename GetInventorySchemaRequestT = Model::GetInventorySchemaRequest>
        Model::GetInventorySchemaOutcomeCallable GetInventorySchemaCallable(const GetInventorySchemaRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::GetInventorySchema, request);
        }
 
        template<typename GetInventorySchemaRequestT = Model::GetInventorySchemaRequest>
        void GetInventorySchemaAsync(const GetInventorySchemaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetInventorySchemaRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::GetInventorySchema, request, handler, context);
        }
 
        virtual Model::GetMaintenanceWindowOutcome GetMaintenanceWindow(const Model::GetMaintenanceWindowRequest& request) const;
 
        template<typename GetMaintenanceWindowRequestT = Model::GetMaintenanceWindowRequest>
        Model::GetMaintenanceWindowOutcomeCallable GetMaintenanceWindowCallable(const GetMaintenanceWindowRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetMaintenanceWindow, request);
        }
 
        template<typename GetMaintenanceWindowRequestT = Model::GetMaintenanceWindowRequest>
        void GetMaintenanceWindowAsync(const GetMaintenanceWindowRequestT& request, const GetMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetMaintenanceWindow, request, handler, context);
        }
 
        virtual Model::GetMaintenanceWindowExecutionOutcome GetMaintenanceWindowExecution(const Model::GetMaintenanceWindowExecutionRequest& request) const;
 
        template<typename GetMaintenanceWindowExecutionRequestT = Model::GetMaintenanceWindowExecutionRequest>
        Model::GetMaintenanceWindowExecutionOutcomeCallable GetMaintenanceWindowExecutionCallable(const GetMaintenanceWindowExecutionRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetMaintenanceWindowExecution, request);
        }
 
        template<typename GetMaintenanceWindowExecutionRequestT = Model::GetMaintenanceWindowExecutionRequest>
        void GetMaintenanceWindowExecutionAsync(const GetMaintenanceWindowExecutionRequestT& request, const GetMaintenanceWindowExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetMaintenanceWindowExecution, request, handler, context);
        }
 
        virtual Model::GetMaintenanceWindowExecutionTaskOutcome GetMaintenanceWindowExecutionTask(const Model::GetMaintenanceWindowExecutionTaskRequest& request) const;
 
        template<typename GetMaintenanceWindowExecutionTaskRequestT = Model::GetMaintenanceWindowExecutionTaskRequest>
        Model::GetMaintenanceWindowExecutionTaskOutcomeCallable GetMaintenanceWindowExecutionTaskCallable(const GetMaintenanceWindowExecutionTaskRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetMaintenanceWindowExecutionTask, request);
        }
 
        template<typename GetMaintenanceWindowExecutionTaskRequestT = Model::GetMaintenanceWindowExecutionTaskRequest>
        void GetMaintenanceWindowExecutionTaskAsync(const GetMaintenanceWindowExecutionTaskRequestT& request, const GetMaintenanceWindowExecutionTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetMaintenanceWindowExecutionTask, request, handler, context);
        }
 
        virtual Model::GetMaintenanceWindowExecutionTaskInvocationOutcome GetMaintenanceWindowExecutionTaskInvocation(const Model::GetMaintenanceWindowExecutionTaskInvocationRequest& request) const;
 
        template<typename GetMaintenanceWindowExecutionTaskInvocationRequestT = Model::GetMaintenanceWindowExecutionTaskInvocationRequest>
        Model::GetMaintenanceWindowExecutionTaskInvocationOutcomeCallable GetMaintenanceWindowExecutionTaskInvocationCallable(const GetMaintenanceWindowExecutionTaskInvocationRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetMaintenanceWindowExecutionTaskInvocation, request);
        }
 
        template<typename GetMaintenanceWindowExecutionTaskInvocationRequestT = Model::GetMaintenanceWindowExecutionTaskInvocationRequest>
        void GetMaintenanceWindowExecutionTaskInvocationAsync(const GetMaintenanceWindowExecutionTaskInvocationRequestT& request, const GetMaintenanceWindowExecutionTaskInvocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetMaintenanceWindowExecutionTaskInvocation, request, handler, context);
        }
 
        virtual Model::GetMaintenanceWindowTaskOutcome GetMaintenanceWindowTask(const Model::GetMaintenanceWindowTaskRequest& request) const;
 
        template<typename GetMaintenanceWindowTaskRequestT = Model::GetMaintenanceWindowTaskRequest>
        Model::GetMaintenanceWindowTaskOutcomeCallable GetMaintenanceWindowTaskCallable(const GetMaintenanceWindowTaskRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetMaintenanceWindowTask, request);
        }
 
        template<typename GetMaintenanceWindowTaskRequestT = Model::GetMaintenanceWindowTaskRequest>
        void GetMaintenanceWindowTaskAsync(const GetMaintenanceWindowTaskRequestT& request, const GetMaintenanceWindowTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetMaintenanceWindowTask, request, handler, context);
        }
 
        virtual Model::GetOpsItemOutcome GetOpsItem(const Model::GetOpsItemRequest& request) const;
 
        template<typename GetOpsItemRequestT = Model::GetOpsItemRequest>
        Model::GetOpsItemOutcomeCallable GetOpsItemCallable(const GetOpsItemRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetOpsItem, request);
        }
 
        template<typename GetOpsItemRequestT = Model::GetOpsItemRequest>
        void GetOpsItemAsync(const GetOpsItemRequestT& request, const GetOpsItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetOpsItem, request, handler, context);
        }
 
        virtual Model::GetOpsMetadataOutcome GetOpsMetadata(const Model::GetOpsMetadataRequest& request) const;
 
        template<typename GetOpsMetadataRequestT = Model::GetOpsMetadataRequest>
        Model::GetOpsMetadataOutcomeCallable GetOpsMetadataCallable(const GetOpsMetadataRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetOpsMetadata, request);
        }
 
        template<typename GetOpsMetadataRequestT = Model::GetOpsMetadataRequest>
        void GetOpsMetadataAsync(const GetOpsMetadataRequestT& request, const GetOpsMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetOpsMetadata, request, handler, context);
        }
 
        virtual Model::GetOpsSummaryOutcome GetOpsSummary(const Model::GetOpsSummaryRequest& request = {}) const;
 
        template<typename GetOpsSummaryRequestT = Model::GetOpsSummaryRequest>
        Model::GetOpsSummaryOutcomeCallable GetOpsSummaryCallable(const GetOpsSummaryRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::GetOpsSummary, request);
        }
 
        template<typename GetOpsSummaryRequestT = Model::GetOpsSummaryRequest>
        void GetOpsSummaryAsync(const GetOpsSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetOpsSummaryRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::GetOpsSummary, request, handler, context);
        }
 
        virtual Model::GetParameterOutcome GetParameter(const Model::GetParameterRequest& request) const;
 
        template<typename GetParameterRequestT = Model::GetParameterRequest>
        Model::GetParameterOutcomeCallable GetParameterCallable(const GetParameterRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetParameter, request);
        }
 
        template<typename GetParameterRequestT = Model::GetParameterRequest>
        void GetParameterAsync(const GetParameterRequestT& request, const GetParameterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetParameter, request, handler, context);
        }
 
        virtual Model::GetParameterHistoryOutcome GetParameterHistory(const Model::GetParameterHistoryRequest& request) const;
 
        template<typename GetParameterHistoryRequestT = Model::GetParameterHistoryRequest>
        Model::GetParameterHistoryOutcomeCallable GetParameterHistoryCallable(const GetParameterHistoryRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetParameterHistory, request);
        }
 
        template<typename GetParameterHistoryRequestT = Model::GetParameterHistoryRequest>
        void GetParameterHistoryAsync(const GetParameterHistoryRequestT& request, const GetParameterHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetParameterHistory, request, handler, context);
        }
 
        virtual Model::GetParametersOutcome GetParameters(const Model::GetParametersRequest& request) const;
 
        template<typename GetParametersRequestT = Model::GetParametersRequest>
        Model::GetParametersOutcomeCallable GetParametersCallable(const GetParametersRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetParameters, request);
        }
 
        template<typename GetParametersRequestT = Model::GetParametersRequest>
        void GetParametersAsync(const GetParametersRequestT& request, const GetParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetParameters, request, handler, context);
        }
 
        virtual Model::GetParametersByPathOutcome GetParametersByPath(const Model::GetParametersByPathRequest& request) const;
 
        template<typename GetParametersByPathRequestT = Model::GetParametersByPathRequest>
        Model::GetParametersByPathOutcomeCallable GetParametersByPathCallable(const GetParametersByPathRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetParametersByPath, request);
        }
 
        template<typename GetParametersByPathRequestT = Model::GetParametersByPathRequest>
        void GetParametersByPathAsync(const GetParametersByPathRequestT& request, const GetParametersByPathResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetParametersByPath, request, handler, context);
        }
 
        virtual Model::GetPatchBaselineOutcome GetPatchBaseline(const Model::GetPatchBaselineRequest& request) const;
 
        template<typename GetPatchBaselineRequestT = Model::GetPatchBaselineRequest>
        Model::GetPatchBaselineOutcomeCallable GetPatchBaselineCallable(const GetPatchBaselineRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetPatchBaseline, request);
        }
 
        template<typename GetPatchBaselineRequestT = Model::GetPatchBaselineRequest>
        void GetPatchBaselineAsync(const GetPatchBaselineRequestT& request, const GetPatchBaselineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetPatchBaseline, request, handler, context);
        }
 
        virtual Model::GetPatchBaselineForPatchGroupOutcome GetPatchBaselineForPatchGroup(const Model::GetPatchBaselineForPatchGroupRequest& request) const;
 
        template<typename GetPatchBaselineForPatchGroupRequestT = Model::GetPatchBaselineForPatchGroupRequest>
        Model::GetPatchBaselineForPatchGroupOutcomeCallable GetPatchBaselineForPatchGroupCallable(const GetPatchBaselineForPatchGroupRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetPatchBaselineForPatchGroup, request);
        }
 
        template<typename GetPatchBaselineForPatchGroupRequestT = Model::GetPatchBaselineForPatchGroupRequest>
        void GetPatchBaselineForPatchGroupAsync(const GetPatchBaselineForPatchGroupRequestT& request, const GetPatchBaselineForPatchGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetPatchBaselineForPatchGroup, request, handler, context);
        }
 
        virtual Model::GetResourcePoliciesOutcome GetResourcePolicies(const Model::GetResourcePoliciesRequest& request) const;
 
        template<typename GetResourcePoliciesRequestT = Model::GetResourcePoliciesRequest>
        Model::GetResourcePoliciesOutcomeCallable GetResourcePoliciesCallable(const GetResourcePoliciesRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetResourcePolicies, request);
        }
 
        template<typename GetResourcePoliciesRequestT = Model::GetResourcePoliciesRequest>
        void GetResourcePoliciesAsync(const GetResourcePoliciesRequestT& request, const GetResourcePoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetResourcePolicies, request, handler, context);
        }
 
        virtual Model::GetServiceSettingOutcome GetServiceSetting(const Model::GetServiceSettingRequest& request) const;
 
        template<typename GetServiceSettingRequestT = Model::GetServiceSettingRequest>
        Model::GetServiceSettingOutcomeCallable GetServiceSettingCallable(const GetServiceSettingRequestT& request) const
        {
            return SubmitCallable(&SSMClient::GetServiceSetting, request);
        }
 
        template<typename GetServiceSettingRequestT = Model::GetServiceSettingRequest>
        void GetServiceSettingAsync(const GetServiceSettingRequestT& request, const GetServiceSettingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::GetServiceSetting, request, handler, context);
        }
 
        virtual Model::LabelParameterVersionOutcome LabelParameterVersion(const Model::LabelParameterVersionRequest& request) const;
 
        template<typename LabelParameterVersionRequestT = Model::LabelParameterVersionRequest>
        Model::LabelParameterVersionOutcomeCallable LabelParameterVersionCallable(const LabelParameterVersionRequestT& request) const
        {
            return SubmitCallable(&SSMClient::LabelParameterVersion, request);
        }
 
        template<typename LabelParameterVersionRequestT = Model::LabelParameterVersionRequest>
        void LabelParameterVersionAsync(const LabelParameterVersionRequestT& request, const LabelParameterVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::LabelParameterVersion, request, handler, context);
        }
 
        virtual Model::ListAssociationVersionsOutcome ListAssociationVersions(const Model::ListAssociationVersionsRequest& request) const;
 
        template<typename ListAssociationVersionsRequestT = Model::ListAssociationVersionsRequest>
        Model::ListAssociationVersionsOutcomeCallable ListAssociationVersionsCallable(const ListAssociationVersionsRequestT& request) const
        {
            return SubmitCallable(&SSMClient::ListAssociationVersions, request);
        }
 
        template<typename ListAssociationVersionsRequestT = Model::ListAssociationVersionsRequest>
        void ListAssociationVersionsAsync(const ListAssociationVersionsRequestT& request, const ListAssociationVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::ListAssociationVersions, request, handler, context);
        }
 
        virtual Model::ListAssociationsOutcome ListAssociations(const Model::ListAssociationsRequest& request = {}) const;
 
        template<typename ListAssociationsRequestT = Model::ListAssociationsRequest>
        Model::ListAssociationsOutcomeCallable ListAssociationsCallable(const ListAssociationsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::ListAssociations, request);
        }
 
        template<typename ListAssociationsRequestT = Model::ListAssociationsRequest>
        void ListAssociationsAsync(const ListAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAssociationsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::ListAssociations, request, handler, context);
        }
 
        virtual Model::ListCommandInvocationsOutcome ListCommandInvocations(const Model::ListCommandInvocationsRequest& request = {}) const;
 
        template<typename ListCommandInvocationsRequestT = Model::ListCommandInvocationsRequest>
        Model::ListCommandInvocationsOutcomeCallable ListCommandInvocationsCallable(const ListCommandInvocationsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::ListCommandInvocations, request);
        }
 
        template<typename ListCommandInvocationsRequestT = Model::ListCommandInvocationsRequest>
        void ListCommandInvocationsAsync(const ListCommandInvocationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCommandInvocationsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::ListCommandInvocations, request, handler, context);
        }
 
        virtual Model::ListCommandsOutcome ListCommands(const Model::ListCommandsRequest& request = {}) const;
 
        template<typename ListCommandsRequestT = Model::ListCommandsRequest>
        Model::ListCommandsOutcomeCallable ListCommandsCallable(const ListCommandsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::ListCommands, request);
        }
 
        template<typename ListCommandsRequestT = Model::ListCommandsRequest>
        void ListCommandsAsync(const ListCommandsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCommandsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::ListCommands, request, handler, context);
        }
 
        virtual Model::ListComplianceItemsOutcome ListComplianceItems(const Model::ListComplianceItemsRequest& request = {}) const;
 
        template<typename ListComplianceItemsRequestT = Model::ListComplianceItemsRequest>
        Model::ListComplianceItemsOutcomeCallable ListComplianceItemsCallable(const ListComplianceItemsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::ListComplianceItems, request);
        }
 
        template<typename ListComplianceItemsRequestT = Model::ListComplianceItemsRequest>
        void ListComplianceItemsAsync(const ListComplianceItemsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListComplianceItemsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::ListComplianceItems, request, handler, context);
        }
 
        virtual Model::ListComplianceSummariesOutcome ListComplianceSummaries(const Model::ListComplianceSummariesRequest& request = {}) const;
 
        template<typename ListComplianceSummariesRequestT = Model::ListComplianceSummariesRequest>
        Model::ListComplianceSummariesOutcomeCallable ListComplianceSummariesCallable(const ListComplianceSummariesRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::ListComplianceSummaries, request);
        }
 
        template<typename ListComplianceSummariesRequestT = Model::ListComplianceSummariesRequest>
        void ListComplianceSummariesAsync(const ListComplianceSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListComplianceSummariesRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::ListComplianceSummaries, request, handler, context);
        }
 
        virtual Model::ListDocumentMetadataHistoryOutcome ListDocumentMetadataHistory(const Model::ListDocumentMetadataHistoryRequest& request) const;
 
        template<typename ListDocumentMetadataHistoryRequestT = Model::ListDocumentMetadataHistoryRequest>
        Model::ListDocumentMetadataHistoryOutcomeCallable ListDocumentMetadataHistoryCallable(const ListDocumentMetadataHistoryRequestT& request) const
        {
            return SubmitCallable(&SSMClient::ListDocumentMetadataHistory, request);
        }
 
        template<typename ListDocumentMetadataHistoryRequestT = Model::ListDocumentMetadataHistoryRequest>
        void ListDocumentMetadataHistoryAsync(const ListDocumentMetadataHistoryRequestT& request, const ListDocumentMetadataHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::ListDocumentMetadataHistory, request, handler, context);
        }
 
        virtual Model::ListDocumentVersionsOutcome ListDocumentVersions(const Model::ListDocumentVersionsRequest& request) const;
 
        template<typename ListDocumentVersionsRequestT = Model::ListDocumentVersionsRequest>
        Model::ListDocumentVersionsOutcomeCallable ListDocumentVersionsCallable(const ListDocumentVersionsRequestT& request) const
        {
            return SubmitCallable(&SSMClient::ListDocumentVersions, request);
        }
 
        template<typename ListDocumentVersionsRequestT = Model::ListDocumentVersionsRequest>
        void ListDocumentVersionsAsync(const ListDocumentVersionsRequestT& request, const ListDocumentVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::ListDocumentVersions, request, handler, context);
        }
 
        virtual Model::ListDocumentsOutcome ListDocuments(const Model::ListDocumentsRequest& request = {}) const;
 
        template<typename ListDocumentsRequestT = Model::ListDocumentsRequest>
        Model::ListDocumentsOutcomeCallable ListDocumentsCallable(const ListDocumentsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::ListDocuments, request);
        }
 
        template<typename ListDocumentsRequestT = Model::ListDocumentsRequest>
        void ListDocumentsAsync(const ListDocumentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDocumentsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::ListDocuments, request, handler, context);
        }
 
        virtual Model::ListInventoryEntriesOutcome ListInventoryEntries(const Model::ListInventoryEntriesRequest& request) const;
 
        template<typename ListInventoryEntriesRequestT = Model::ListInventoryEntriesRequest>
        Model::ListInventoryEntriesOutcomeCallable ListInventoryEntriesCallable(const ListInventoryEntriesRequestT& request) const
        {
            return SubmitCallable(&SSMClient::ListInventoryEntries, request);
        }
 
        template<typename ListInventoryEntriesRequestT = Model::ListInventoryEntriesRequest>
        void ListInventoryEntriesAsync(const ListInventoryEntriesRequestT& request, const ListInventoryEntriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::ListInventoryEntries, request, handler, context);
        }
 
        virtual Model::ListNodesOutcome ListNodes(const Model::ListNodesRequest& request = {}) const;
 
        template<typename ListNodesRequestT = Model::ListNodesRequest>
        Model::ListNodesOutcomeCallable ListNodesCallable(const ListNodesRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::ListNodes, request);
        }
 
        template<typename ListNodesRequestT = Model::ListNodesRequest>
        void ListNodesAsync(const ListNodesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListNodesRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::ListNodes, request, handler, context);
        }
 
        virtual Model::ListNodesSummaryOutcome ListNodesSummary(const Model::ListNodesSummaryRequest& request) const;
 
        template<typename ListNodesSummaryRequestT = Model::ListNodesSummaryRequest>
        Model::ListNodesSummaryOutcomeCallable ListNodesSummaryCallable(const ListNodesSummaryRequestT& request) const
        {
            return SubmitCallable(&SSMClient::ListNodesSummary, request);
        }
 
        template<typename ListNodesSummaryRequestT = Model::ListNodesSummaryRequest>
        void ListNodesSummaryAsync(const ListNodesSummaryRequestT& request, const ListNodesSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::ListNodesSummary, request, handler, context);
        }
 
        virtual Model::ListOpsItemEventsOutcome ListOpsItemEvents(const Model::ListOpsItemEventsRequest& request = {}) const;
 
        template<typename ListOpsItemEventsRequestT = Model::ListOpsItemEventsRequest>
        Model::ListOpsItemEventsOutcomeCallable ListOpsItemEventsCallable(const ListOpsItemEventsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::ListOpsItemEvents, request);
        }
 
        template<typename ListOpsItemEventsRequestT = Model::ListOpsItemEventsRequest>
        void ListOpsItemEventsAsync(const ListOpsItemEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOpsItemEventsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::ListOpsItemEvents, request, handler, context);
        }
 
        virtual Model::ListOpsItemRelatedItemsOutcome ListOpsItemRelatedItems(const Model::ListOpsItemRelatedItemsRequest& request = {}) const;
 
        template<typename ListOpsItemRelatedItemsRequestT = Model::ListOpsItemRelatedItemsRequest>
        Model::ListOpsItemRelatedItemsOutcomeCallable ListOpsItemRelatedItemsCallable(const ListOpsItemRelatedItemsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::ListOpsItemRelatedItems, request);
        }
 
        template<typename ListOpsItemRelatedItemsRequestT = Model::ListOpsItemRelatedItemsRequest>
        void ListOpsItemRelatedItemsAsync(const ListOpsItemRelatedItemsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOpsItemRelatedItemsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::ListOpsItemRelatedItems, request, handler, context);
        }
 
        virtual Model::ListOpsMetadataOutcome ListOpsMetadata(const Model::ListOpsMetadataRequest& request = {}) const;
 
        template<typename ListOpsMetadataRequestT = Model::ListOpsMetadataRequest>
        Model::ListOpsMetadataOutcomeCallable ListOpsMetadataCallable(const ListOpsMetadataRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::ListOpsMetadata, request);
        }
 
        template<typename ListOpsMetadataRequestT = Model::ListOpsMetadataRequest>
        void ListOpsMetadataAsync(const ListOpsMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOpsMetadataRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::ListOpsMetadata, request, handler, context);
        }
 
        virtual Model::ListResourceComplianceSummariesOutcome ListResourceComplianceSummaries(const Model::ListResourceComplianceSummariesRequest& request = {}) const;
 
        template<typename ListResourceComplianceSummariesRequestT = Model::ListResourceComplianceSummariesRequest>
        Model::ListResourceComplianceSummariesOutcomeCallable ListResourceComplianceSummariesCallable(const ListResourceComplianceSummariesRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::ListResourceComplianceSummaries, request);
        }
 
        template<typename ListResourceComplianceSummariesRequestT = Model::ListResourceComplianceSummariesRequest>
        void ListResourceComplianceSummariesAsync(const ListResourceComplianceSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListResourceComplianceSummariesRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::ListResourceComplianceSummaries, request, handler, context);
        }
 
        virtual Model::ListResourceDataSyncOutcome ListResourceDataSync(const Model::ListResourceDataSyncRequest& request = {}) const;
 
        template<typename ListResourceDataSyncRequestT = Model::ListResourceDataSyncRequest>
        Model::ListResourceDataSyncOutcomeCallable ListResourceDataSyncCallable(const ListResourceDataSyncRequestT& request = {}) const
        {
            return SubmitCallable(&SSMClient::ListResourceDataSync, request);
        }
 
        template<typename ListResourceDataSyncRequestT = Model::ListResourceDataSyncRequest>
        void ListResourceDataSyncAsync(const ListResourceDataSyncResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListResourceDataSyncRequestT& request = {}) const
        {
            return SubmitAsync(&SSMClient::ListResourceDataSync, 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(&SSMClient::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(&SSMClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ModifyDocumentPermissionOutcome ModifyDocumentPermission(const Model::ModifyDocumentPermissionRequest& request) const;
 
        template<typename ModifyDocumentPermissionRequestT = Model::ModifyDocumentPermissionRequest>
        Model::ModifyDocumentPermissionOutcomeCallable ModifyDocumentPermissionCallable(const ModifyDocumentPermissionRequestT& request) const
        {
            return SubmitCallable(&SSMClient::ModifyDocumentPermission, request);
        }
 
        template<typename ModifyDocumentPermissionRequestT = Model::ModifyDocumentPermissionRequest>
        void ModifyDocumentPermissionAsync(const ModifyDocumentPermissionRequestT& request, const ModifyDocumentPermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::ModifyDocumentPermission, request, handler, context);
        }
 
        virtual Model::PutComplianceItemsOutcome PutComplianceItems(const Model::PutComplianceItemsRequest& request) const;
 
        template<typename PutComplianceItemsRequestT = Model::PutComplianceItemsRequest>
        Model::PutComplianceItemsOutcomeCallable PutComplianceItemsCallable(const PutComplianceItemsRequestT& request) const
        {
            return SubmitCallable(&SSMClient::PutComplianceItems, request);
        }
 
        template<typename PutComplianceItemsRequestT = Model::PutComplianceItemsRequest>
        void PutComplianceItemsAsync(const PutComplianceItemsRequestT& request, const PutComplianceItemsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::PutComplianceItems, request, handler, context);
        }
 
        virtual Model::PutInventoryOutcome PutInventory(const Model::PutInventoryRequest& request) const;
 
        template<typename PutInventoryRequestT = Model::PutInventoryRequest>
        Model::PutInventoryOutcomeCallable PutInventoryCallable(const PutInventoryRequestT& request) const
        {
            return SubmitCallable(&SSMClient::PutInventory, request);
        }
 
        template<typename PutInventoryRequestT = Model::PutInventoryRequest>
        void PutInventoryAsync(const PutInventoryRequestT& request, const PutInventoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::PutInventory, request, handler, context);
        }
 
        virtual Model::PutParameterOutcome PutParameter(const Model::PutParameterRequest& request) const;
 
        template<typename PutParameterRequestT = Model::PutParameterRequest>
        Model::PutParameterOutcomeCallable PutParameterCallable(const PutParameterRequestT& request) const
        {
            return SubmitCallable(&SSMClient::PutParameter, request);
        }
 
        template<typename PutParameterRequestT = Model::PutParameterRequest>
        void PutParameterAsync(const PutParameterRequestT& request, const PutParameterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::PutParameter, request, handler, context);
        }
 
        virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&SSMClient::PutResourcePolicy, request);
        }
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::PutResourcePolicy, request, handler, context);
        }
 
        virtual Model::RegisterDefaultPatchBaselineOutcome RegisterDefaultPatchBaseline(const Model::RegisterDefaultPatchBaselineRequest& request) const;
 
        template<typename RegisterDefaultPatchBaselineRequestT = Model::RegisterDefaultPatchBaselineRequest>
        Model::RegisterDefaultPatchBaselineOutcomeCallable RegisterDefaultPatchBaselineCallable(const RegisterDefaultPatchBaselineRequestT& request) const
        {
            return SubmitCallable(&SSMClient::RegisterDefaultPatchBaseline, request);
        }
 
        template<typename RegisterDefaultPatchBaselineRequestT = Model::RegisterDefaultPatchBaselineRequest>
        void RegisterDefaultPatchBaselineAsync(const RegisterDefaultPatchBaselineRequestT& request, const RegisterDefaultPatchBaselineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::RegisterDefaultPatchBaseline, request, handler, context);
        }
 
        virtual Model::RegisterPatchBaselineForPatchGroupOutcome RegisterPatchBaselineForPatchGroup(const Model::RegisterPatchBaselineForPatchGroupRequest& request) const;
 
        template<typename RegisterPatchBaselineForPatchGroupRequestT = Model::RegisterPatchBaselineForPatchGroupRequest>
        Model::RegisterPatchBaselineForPatchGroupOutcomeCallable RegisterPatchBaselineForPatchGroupCallable(const RegisterPatchBaselineForPatchGroupRequestT& request) const
        {
            return SubmitCallable(&SSMClient::RegisterPatchBaselineForPatchGroup, request);
        }
 
        template<typename RegisterPatchBaselineForPatchGroupRequestT = Model::RegisterPatchBaselineForPatchGroupRequest>
        void RegisterPatchBaselineForPatchGroupAsync(const RegisterPatchBaselineForPatchGroupRequestT& request, const RegisterPatchBaselineForPatchGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::RegisterPatchBaselineForPatchGroup, request, handler, context);
        }
 
        virtual Model::RegisterTargetWithMaintenanceWindowOutcome RegisterTargetWithMaintenanceWindow(const Model::RegisterTargetWithMaintenanceWindowRequest& request) const;
 
        template<typename RegisterTargetWithMaintenanceWindowRequestT = Model::RegisterTargetWithMaintenanceWindowRequest>
        Model::RegisterTargetWithMaintenanceWindowOutcomeCallable RegisterTargetWithMaintenanceWindowCallable(const RegisterTargetWithMaintenanceWindowRequestT& request) const
        {
            return SubmitCallable(&SSMClient::RegisterTargetWithMaintenanceWindow, request);
        }
 
        template<typename RegisterTargetWithMaintenanceWindowRequestT = Model::RegisterTargetWithMaintenanceWindowRequest>
        void RegisterTargetWithMaintenanceWindowAsync(const RegisterTargetWithMaintenanceWindowRequestT& request, const RegisterTargetWithMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::RegisterTargetWithMaintenanceWindow, request, handler, context);
        }
 
        virtual Model::RegisterTaskWithMaintenanceWindowOutcome RegisterTaskWithMaintenanceWindow(const Model::RegisterTaskWithMaintenanceWindowRequest& request) const;
 
        template<typename RegisterTaskWithMaintenanceWindowRequestT = Model::RegisterTaskWithMaintenanceWindowRequest>
        Model::RegisterTaskWithMaintenanceWindowOutcomeCallable RegisterTaskWithMaintenanceWindowCallable(const RegisterTaskWithMaintenanceWindowRequestT& request) const
        {
            return SubmitCallable(&SSMClient::RegisterTaskWithMaintenanceWindow, request);
        }
 
        template<typename RegisterTaskWithMaintenanceWindowRequestT = Model::RegisterTaskWithMaintenanceWindowRequest>
        void RegisterTaskWithMaintenanceWindowAsync(const RegisterTaskWithMaintenanceWindowRequestT& request, const RegisterTaskWithMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::RegisterTaskWithMaintenanceWindow, 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(&SSMClient::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(&SSMClient::RemoveTagsFromResource, request, handler, context);
        }
 
        virtual Model::ResetServiceSettingOutcome ResetServiceSetting(const Model::ResetServiceSettingRequest& request) const;
 
        template<typename ResetServiceSettingRequestT = Model::ResetServiceSettingRequest>
        Model::ResetServiceSettingOutcomeCallable ResetServiceSettingCallable(const ResetServiceSettingRequestT& request) const
        {
            return SubmitCallable(&SSMClient::ResetServiceSetting, request);
        }
 
        template<typename ResetServiceSettingRequestT = Model::ResetServiceSettingRequest>
        void ResetServiceSettingAsync(const ResetServiceSettingRequestT& request, const ResetServiceSettingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::ResetServiceSetting, request, handler, context);
        }
 
        virtual Model::ResumeSessionOutcome ResumeSession(const Model::ResumeSessionRequest& request) const;
 
        template<typename ResumeSessionRequestT = Model::ResumeSessionRequest>
        Model::ResumeSessionOutcomeCallable ResumeSessionCallable(const ResumeSessionRequestT& request) const
        {
            return SubmitCallable(&SSMClient::ResumeSession, request);
        }
 
        template<typename ResumeSessionRequestT = Model::ResumeSessionRequest>
        void ResumeSessionAsync(const ResumeSessionRequestT& request, const ResumeSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::ResumeSession, request, handler, context);
        }
 
        virtual Model::SendAutomationSignalOutcome SendAutomationSignal(const Model::SendAutomationSignalRequest& request) const;
 
        template<typename SendAutomationSignalRequestT = Model::SendAutomationSignalRequest>
        Model::SendAutomationSignalOutcomeCallable SendAutomationSignalCallable(const SendAutomationSignalRequestT& request) const
        {
            return SubmitCallable(&SSMClient::SendAutomationSignal, request);
        }
 
        template<typename SendAutomationSignalRequestT = Model::SendAutomationSignalRequest>
        void SendAutomationSignalAsync(const SendAutomationSignalRequestT& request, const SendAutomationSignalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::SendAutomationSignal, request, handler, context);
        }
 
        virtual Model::SendCommandOutcome SendCommand(const Model::SendCommandRequest& request) const;
 
        template<typename SendCommandRequestT = Model::SendCommandRequest>
        Model::SendCommandOutcomeCallable SendCommandCallable(const SendCommandRequestT& request) const
        {
            return SubmitCallable(&SSMClient::SendCommand, request);
        }
 
        template<typename SendCommandRequestT = Model::SendCommandRequest>
        void SendCommandAsync(const SendCommandRequestT& request, const SendCommandResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::SendCommand, request, handler, context);
        }
 
        virtual Model::StartAccessRequestOutcome StartAccessRequest(const Model::StartAccessRequestRequest& request) const;
 
        template<typename StartAccessRequestRequestT = Model::StartAccessRequestRequest>
        Model::StartAccessRequestOutcomeCallable StartAccessRequestCallable(const StartAccessRequestRequestT& request) const
        {
            return SubmitCallable(&SSMClient::StartAccessRequest, request);
        }
 
        template<typename StartAccessRequestRequestT = Model::StartAccessRequestRequest>
        void StartAccessRequestAsync(const StartAccessRequestRequestT& request, const StartAccessRequestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::StartAccessRequest, request, handler, context);
        }
 
        virtual Model::StartAssociationsOnceOutcome StartAssociationsOnce(const Model::StartAssociationsOnceRequest& request) const;
 
        template<typename StartAssociationsOnceRequestT = Model::StartAssociationsOnceRequest>
        Model::StartAssociationsOnceOutcomeCallable StartAssociationsOnceCallable(const StartAssociationsOnceRequestT& request) const
        {
            return SubmitCallable(&SSMClient::StartAssociationsOnce, request);
        }
 
        template<typename StartAssociationsOnceRequestT = Model::StartAssociationsOnceRequest>
        void StartAssociationsOnceAsync(const StartAssociationsOnceRequestT& request, const StartAssociationsOnceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::StartAssociationsOnce, request, handler, context);
        }
 
        virtual Model::StartAutomationExecutionOutcome StartAutomationExecution(const Model::StartAutomationExecutionRequest& request) const;
 
        template<typename StartAutomationExecutionRequestT = Model::StartAutomationExecutionRequest>
        Model::StartAutomationExecutionOutcomeCallable StartAutomationExecutionCallable(const StartAutomationExecutionRequestT& request) const
        {
            return SubmitCallable(&SSMClient::StartAutomationExecution, request);
        }
 
        template<typename StartAutomationExecutionRequestT = Model::StartAutomationExecutionRequest>
        void StartAutomationExecutionAsync(const StartAutomationExecutionRequestT& request, const StartAutomationExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::StartAutomationExecution, request, handler, context);
        }
 
        virtual Model::StartChangeRequestExecutionOutcome StartChangeRequestExecution(const Model::StartChangeRequestExecutionRequest& request) const;
 
        template<typename StartChangeRequestExecutionRequestT = Model::StartChangeRequestExecutionRequest>
        Model::StartChangeRequestExecutionOutcomeCallable StartChangeRequestExecutionCallable(const StartChangeRequestExecutionRequestT& request) const
        {
            return SubmitCallable(&SSMClient::StartChangeRequestExecution, request);
        }
 
        template<typename StartChangeRequestExecutionRequestT = Model::StartChangeRequestExecutionRequest>
        void StartChangeRequestExecutionAsync(const StartChangeRequestExecutionRequestT& request, const StartChangeRequestExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::StartChangeRequestExecution, request, handler, context);
        }
 
        virtual Model::StartExecutionPreviewOutcome StartExecutionPreview(const Model::StartExecutionPreviewRequest& request) const;
 
        template<typename StartExecutionPreviewRequestT = Model::StartExecutionPreviewRequest>
        Model::StartExecutionPreviewOutcomeCallable StartExecutionPreviewCallable(const StartExecutionPreviewRequestT& request) const
        {
            return SubmitCallable(&SSMClient::StartExecutionPreview, request);
        }
 
        template<typename StartExecutionPreviewRequestT = Model::StartExecutionPreviewRequest>
        void StartExecutionPreviewAsync(const StartExecutionPreviewRequestT& request, const StartExecutionPreviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::StartExecutionPreview, request, handler, context);
        }
 
        virtual Model::StartSessionOutcome StartSession(const Model::StartSessionRequest& request) const;
 
        template<typename StartSessionRequestT = Model::StartSessionRequest>
        Model::StartSessionOutcomeCallable StartSessionCallable(const StartSessionRequestT& request) const
        {
            return SubmitCallable(&SSMClient::StartSession, request);
        }
 
        template<typename StartSessionRequestT = Model::StartSessionRequest>
        void StartSessionAsync(const StartSessionRequestT& request, const StartSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::StartSession, request, handler, context);
        }
 
        virtual Model::StopAutomationExecutionOutcome StopAutomationExecution(const Model::StopAutomationExecutionRequest& request) const;
 
        template<typename StopAutomationExecutionRequestT = Model::StopAutomationExecutionRequest>
        Model::StopAutomationExecutionOutcomeCallable StopAutomationExecutionCallable(const StopAutomationExecutionRequestT& request) const
        {
            return SubmitCallable(&SSMClient::StopAutomationExecution, request);
        }
 
        template<typename StopAutomationExecutionRequestT = Model::StopAutomationExecutionRequest>
        void StopAutomationExecutionAsync(const StopAutomationExecutionRequestT& request, const StopAutomationExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::StopAutomationExecution, request, handler, context);
        }
 
        virtual Model::TerminateSessionOutcome TerminateSession(const Model::TerminateSessionRequest& request) const;
 
        template<typename TerminateSessionRequestT = Model::TerminateSessionRequest>
        Model::TerminateSessionOutcomeCallable TerminateSessionCallable(const TerminateSessionRequestT& request) const
        {
            return SubmitCallable(&SSMClient::TerminateSession, request);
        }
 
        template<typename TerminateSessionRequestT = Model::TerminateSessionRequest>
        void TerminateSessionAsync(const TerminateSessionRequestT& request, const TerminateSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::TerminateSession, request, handler, context);
        }
 
        virtual Model::UnlabelParameterVersionOutcome UnlabelParameterVersion(const Model::UnlabelParameterVersionRequest& request) const;
 
        template<typename UnlabelParameterVersionRequestT = Model::UnlabelParameterVersionRequest>
        Model::UnlabelParameterVersionOutcomeCallable UnlabelParameterVersionCallable(const UnlabelParameterVersionRequestT& request) const
        {
            return SubmitCallable(&SSMClient::UnlabelParameterVersion, request);
        }
 
        template<typename UnlabelParameterVersionRequestT = Model::UnlabelParameterVersionRequest>
        void UnlabelParameterVersionAsync(const UnlabelParameterVersionRequestT& request, const UnlabelParameterVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::UnlabelParameterVersion, request, handler, context);
        }
 
        virtual Model::UpdateAssociationOutcome UpdateAssociation(const Model::UpdateAssociationRequest& request) const;
 
        template<typename UpdateAssociationRequestT = Model::UpdateAssociationRequest>
        Model::UpdateAssociationOutcomeCallable UpdateAssociationCallable(const UpdateAssociationRequestT& request) const
        {
            return SubmitCallable(&SSMClient::UpdateAssociation, request);
        }
 
        template<typename UpdateAssociationRequestT = Model::UpdateAssociationRequest>
        void UpdateAssociationAsync(const UpdateAssociationRequestT& request, const UpdateAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::UpdateAssociation, request, handler, context);
        }
 
        virtual Model::UpdateAssociationStatusOutcome UpdateAssociationStatus(const Model::UpdateAssociationStatusRequest& request) const;
 
        template<typename UpdateAssociationStatusRequestT = Model::UpdateAssociationStatusRequest>
        Model::UpdateAssociationStatusOutcomeCallable UpdateAssociationStatusCallable(const UpdateAssociationStatusRequestT& request) const
        {
            return SubmitCallable(&SSMClient::UpdateAssociationStatus, request);
        }
 
        template<typename UpdateAssociationStatusRequestT = Model::UpdateAssociationStatusRequest>
        void UpdateAssociationStatusAsync(const UpdateAssociationStatusRequestT& request, const UpdateAssociationStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::UpdateAssociationStatus, request, handler, context);
        }
 
        virtual Model::UpdateDocumentOutcome UpdateDocument(const Model::UpdateDocumentRequest& request) const;
 
        template<typename UpdateDocumentRequestT = Model::UpdateDocumentRequest>
        Model::UpdateDocumentOutcomeCallable UpdateDocumentCallable(const UpdateDocumentRequestT& request) const
        {
            return SubmitCallable(&SSMClient::UpdateDocument, request);
        }
 
        template<typename UpdateDocumentRequestT = Model::UpdateDocumentRequest>
        void UpdateDocumentAsync(const UpdateDocumentRequestT& request, const UpdateDocumentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::UpdateDocument, request, handler, context);
        }
 
        virtual Model::UpdateDocumentDefaultVersionOutcome UpdateDocumentDefaultVersion(const Model::UpdateDocumentDefaultVersionRequest& request) const;
 
        template<typename UpdateDocumentDefaultVersionRequestT = Model::UpdateDocumentDefaultVersionRequest>
        Model::UpdateDocumentDefaultVersionOutcomeCallable UpdateDocumentDefaultVersionCallable(const UpdateDocumentDefaultVersionRequestT& request) const
        {
            return SubmitCallable(&SSMClient::UpdateDocumentDefaultVersion, request);
        }
 
        template<typename UpdateDocumentDefaultVersionRequestT = Model::UpdateDocumentDefaultVersionRequest>
        void UpdateDocumentDefaultVersionAsync(const UpdateDocumentDefaultVersionRequestT& request, const UpdateDocumentDefaultVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::UpdateDocumentDefaultVersion, request, handler, context);
        }
 
        virtual Model::UpdateDocumentMetadataOutcome UpdateDocumentMetadata(const Model::UpdateDocumentMetadataRequest& request) const;
 
        template<typename UpdateDocumentMetadataRequestT = Model::UpdateDocumentMetadataRequest>
        Model::UpdateDocumentMetadataOutcomeCallable UpdateDocumentMetadataCallable(const UpdateDocumentMetadataRequestT& request) const
        {
            return SubmitCallable(&SSMClient::UpdateDocumentMetadata, request);
        }
 
        template<typename UpdateDocumentMetadataRequestT = Model::UpdateDocumentMetadataRequest>
        void UpdateDocumentMetadataAsync(const UpdateDocumentMetadataRequestT& request, const UpdateDocumentMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::UpdateDocumentMetadata, request, handler, context);
        }
 
        virtual Model::UpdateMaintenanceWindowOutcome UpdateMaintenanceWindow(const Model::UpdateMaintenanceWindowRequest& request) const;
 
        template<typename UpdateMaintenanceWindowRequestT = Model::UpdateMaintenanceWindowRequest>
        Model::UpdateMaintenanceWindowOutcomeCallable UpdateMaintenanceWindowCallable(const UpdateMaintenanceWindowRequestT& request) const
        {
            return SubmitCallable(&SSMClient::UpdateMaintenanceWindow, request);
        }
 
        template<typename UpdateMaintenanceWindowRequestT = Model::UpdateMaintenanceWindowRequest>
        void UpdateMaintenanceWindowAsync(const UpdateMaintenanceWindowRequestT& request, const UpdateMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::UpdateMaintenanceWindow, request, handler, context);
        }
 
        virtual Model::UpdateMaintenanceWindowTargetOutcome UpdateMaintenanceWindowTarget(const Model::UpdateMaintenanceWindowTargetRequest& request) const;
 
        template<typename UpdateMaintenanceWindowTargetRequestT = Model::UpdateMaintenanceWindowTargetRequest>
        Model::UpdateMaintenanceWindowTargetOutcomeCallable UpdateMaintenanceWindowTargetCallable(const UpdateMaintenanceWindowTargetRequestT& request) const
        {
            return SubmitCallable(&SSMClient::UpdateMaintenanceWindowTarget, request);
        }
 
        template<typename UpdateMaintenanceWindowTargetRequestT = Model::UpdateMaintenanceWindowTargetRequest>
        void UpdateMaintenanceWindowTargetAsync(const UpdateMaintenanceWindowTargetRequestT& request, const UpdateMaintenanceWindowTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::UpdateMaintenanceWindowTarget, request, handler, context);
        }
 
        virtual Model::UpdateMaintenanceWindowTaskOutcome UpdateMaintenanceWindowTask(const Model::UpdateMaintenanceWindowTaskRequest& request) const;
 
        template<typename UpdateMaintenanceWindowTaskRequestT = Model::UpdateMaintenanceWindowTaskRequest>
        Model::UpdateMaintenanceWindowTaskOutcomeCallable UpdateMaintenanceWindowTaskCallable(const UpdateMaintenanceWindowTaskRequestT& request) const
        {
            return SubmitCallable(&SSMClient::UpdateMaintenanceWindowTask, request);
        }
 
        template<typename UpdateMaintenanceWindowTaskRequestT = Model::UpdateMaintenanceWindowTaskRequest>
        void UpdateMaintenanceWindowTaskAsync(const UpdateMaintenanceWindowTaskRequestT& request, const UpdateMaintenanceWindowTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::UpdateMaintenanceWindowTask, request, handler, context);
        }
 
        virtual Model::UpdateManagedInstanceRoleOutcome UpdateManagedInstanceRole(const Model::UpdateManagedInstanceRoleRequest& request) const;
 
        template<typename UpdateManagedInstanceRoleRequestT = Model::UpdateManagedInstanceRoleRequest>
        Model::UpdateManagedInstanceRoleOutcomeCallable UpdateManagedInstanceRoleCallable(const UpdateManagedInstanceRoleRequestT& request) const
        {
            return SubmitCallable(&SSMClient::UpdateManagedInstanceRole, request);
        }
 
        template<typename UpdateManagedInstanceRoleRequestT = Model::UpdateManagedInstanceRoleRequest>
        void UpdateManagedInstanceRoleAsync(const UpdateManagedInstanceRoleRequestT& request, const UpdateManagedInstanceRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::UpdateManagedInstanceRole, request, handler, context);
        }
 
        virtual Model::UpdateOpsItemOutcome UpdateOpsItem(const Model::UpdateOpsItemRequest& request) const;
 
        template<typename UpdateOpsItemRequestT = Model::UpdateOpsItemRequest>
        Model::UpdateOpsItemOutcomeCallable UpdateOpsItemCallable(const UpdateOpsItemRequestT& request) const
        {
            return SubmitCallable(&SSMClient::UpdateOpsItem, request);
        }
 
        template<typename UpdateOpsItemRequestT = Model::UpdateOpsItemRequest>
        void UpdateOpsItemAsync(const UpdateOpsItemRequestT& request, const UpdateOpsItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::UpdateOpsItem, request, handler, context);
        }
 
        virtual Model::UpdateOpsMetadataOutcome UpdateOpsMetadata(const Model::UpdateOpsMetadataRequest& request) const;
 
        template<typename UpdateOpsMetadataRequestT = Model::UpdateOpsMetadataRequest>
        Model::UpdateOpsMetadataOutcomeCallable UpdateOpsMetadataCallable(const UpdateOpsMetadataRequestT& request) const
        {
            return SubmitCallable(&SSMClient::UpdateOpsMetadata, request);
        }
 
        template<typename UpdateOpsMetadataRequestT = Model::UpdateOpsMetadataRequest>
        void UpdateOpsMetadataAsync(const UpdateOpsMetadataRequestT& request, const UpdateOpsMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::UpdateOpsMetadata, request, handler, context);
        }
 
        virtual Model::UpdatePatchBaselineOutcome UpdatePatchBaseline(const Model::UpdatePatchBaselineRequest& request) const;
 
        template<typename UpdatePatchBaselineRequestT = Model::UpdatePatchBaselineRequest>
        Model::UpdatePatchBaselineOutcomeCallable UpdatePatchBaselineCallable(const UpdatePatchBaselineRequestT& request) const
        {
            return SubmitCallable(&SSMClient::UpdatePatchBaseline, request);
        }
 
        template<typename UpdatePatchBaselineRequestT = Model::UpdatePatchBaselineRequest>
        void UpdatePatchBaselineAsync(const UpdatePatchBaselineRequestT& request, const UpdatePatchBaselineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::UpdatePatchBaseline, request, handler, context);
        }
 
        virtual Model::UpdateResourceDataSyncOutcome UpdateResourceDataSync(const Model::UpdateResourceDataSyncRequest& request) const;
 
        template<typename UpdateResourceDataSyncRequestT = Model::UpdateResourceDataSyncRequest>
        Model::UpdateResourceDataSyncOutcomeCallable UpdateResourceDataSyncCallable(const UpdateResourceDataSyncRequestT& request) const
        {
            return SubmitCallable(&SSMClient::UpdateResourceDataSync, request);
        }
 
        template<typename UpdateResourceDataSyncRequestT = Model::UpdateResourceDataSyncRequest>
        void UpdateResourceDataSyncAsync(const UpdateResourceDataSyncRequestT& request, const UpdateResourceDataSyncResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::UpdateResourceDataSync, request, handler, context);
        }
 
        virtual Model::UpdateServiceSettingOutcome UpdateServiceSetting(const Model::UpdateServiceSettingRequest& request) const;
 
        template<typename UpdateServiceSettingRequestT = Model::UpdateServiceSettingRequest>
        Model::UpdateServiceSettingOutcomeCallable UpdateServiceSettingCallable(const UpdateServiceSettingRequestT& request) const
        {
            return SubmitCallable(&SSMClient::UpdateServiceSetting, request);
        }
 
        template<typename UpdateServiceSettingRequestT = Model::UpdateServiceSettingRequest>
        void UpdateServiceSettingAsync(const UpdateServiceSettingRequestT& request, const UpdateServiceSettingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMClient::UpdateServiceSetting, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SSMEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SSMClient>;
      void init(const SSMClientConfiguration& clientConfiguration);
 
      SSMClientConfiguration m_clientConfiguration;
      std::shared_ptr<SSMEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace SSM
} // namespace Aws