SSMClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/ssm/SSMPaginationBase.h>
#include <aws/ssm/SSMServiceClientModel.h>
#include <aws/ssm/SSMWaiter.h>
#include <aws/ssm/SSM_EXPORTS.h>
 
namespace Aws {
namespace SSM {
class AWS_SSM_API SSMClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<SSMClient>,
                              public SSMPaginationBase<SSMClient>,
                              public SSMWaiter<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::CreateCloudConnectorOutcome CreateCloudConnector(const Model::CreateCloudConnectorRequest& request) const;
 
  template <typename CreateCloudConnectorRequestT = Model::CreateCloudConnectorRequest>
  Model::CreateCloudConnectorOutcomeCallable CreateCloudConnectorCallable(const CreateCloudConnectorRequestT& request) const {
    return SubmitCallable(&SSMClient::CreateCloudConnector, request);
  }
 
  template <typename CreateCloudConnectorRequestT = Model::CreateCloudConnectorRequest>
  void CreateCloudConnectorAsync(const CreateCloudConnectorRequestT& request, const CreateCloudConnectorResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSMClient::CreateCloudConnector, 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::DeleteCloudConnectorOutcome DeleteCloudConnector(const Model::DeleteCloudConnectorRequest& request) const;
 
  template <typename DeleteCloudConnectorRequestT = Model::DeleteCloudConnectorRequest>
  Model::DeleteCloudConnectorOutcomeCallable DeleteCloudConnectorCallable(const DeleteCloudConnectorRequestT& request) const {
    return SubmitCallable(&SSMClient::DeleteCloudConnector, request);
  }
 
  template <typename DeleteCloudConnectorRequestT = Model::DeleteCloudConnectorRequest>
  void DeleteCloudConnectorAsync(const DeleteCloudConnectorRequestT& request, const DeleteCloudConnectorResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSMClient::DeleteCloudConnector, 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::GetCloudConnectorOutcome GetCloudConnector(const Model::GetCloudConnectorRequest& request) const;
 
  template <typename GetCloudConnectorRequestT = Model::GetCloudConnectorRequest>
  Model::GetCloudConnectorOutcomeCallable GetCloudConnectorCallable(const GetCloudConnectorRequestT& request) const {
    return SubmitCallable(&SSMClient::GetCloudConnector, request);
  }
 
  template <typename GetCloudConnectorRequestT = Model::GetCloudConnectorRequest>
  void GetCloudConnectorAsync(const GetCloudConnectorRequestT& request, const GetCloudConnectorResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSMClient::GetCloudConnector, 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::ListCloudConnectorsOutcome ListCloudConnectors(const Model::ListCloudConnectorsRequest& request = {}) const;
 
  template <typename ListCloudConnectorsRequestT = Model::ListCloudConnectorsRequest>
  Model::ListCloudConnectorsOutcomeCallable ListCloudConnectorsCallable(const ListCloudConnectorsRequestT& request = {}) const {
    return SubmitCallable(&SSMClient::ListCloudConnectors, request);
  }
 
  template <typename ListCloudConnectorsRequestT = Model::ListCloudConnectorsRequest>
  void ListCloudConnectorsAsync(const ListCloudConnectorsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListCloudConnectorsRequestT& request = {}) const {
    return SubmitAsync(&SSMClient::ListCloudConnectors, 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::UpdateCloudConnectorOutcome UpdateCloudConnector(const Model::UpdateCloudConnectorRequest& request) const;
 
  template <typename UpdateCloudConnectorRequestT = Model::UpdateCloudConnectorRequest>
  Model::UpdateCloudConnectorOutcomeCallable UpdateCloudConnectorCallable(const UpdateCloudConnectorRequestT& request) const {
    return SubmitCallable(&SSMClient::UpdateCloudConnector, request);
  }
 
  template <typename UpdateCloudConnectorRequestT = Model::UpdateCloudConnectorRequest>
  void UpdateCloudConnectorAsync(const UpdateCloudConnectorRequestT& request, const UpdateCloudConnectorResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSMClient::UpdateCloudConnector, 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);
  }
 
  virtual Model::ValidateCloudConnectorOutcome ValidateCloudConnector(const Model::ValidateCloudConnectorRequest& request) const;
 
  template <typename ValidateCloudConnectorRequestT = Model::ValidateCloudConnectorRequest>
  Model::ValidateCloudConnectorOutcomeCallable ValidateCloudConnectorCallable(const ValidateCloudConnectorRequestT& request) const {
    return SubmitCallable(&SSMClient::ValidateCloudConnector, request);
  }
 
  template <typename ValidateCloudConnectorRequestT = Model::ValidateCloudConnectorRequest>
  void ValidateCloudConnectorAsync(const ValidateCloudConnectorRequestT& request,
                                   const ValidateCloudConnectorResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSMClient::ValidateCloudConnector, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SSMEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SSMClient>;
  void init(const SSMClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SSMError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  SSMClientConfiguration m_clientConfiguration;
  std::shared_ptr<SSMEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SSM
}  // namespace Aws