/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace SSM { /** *

Amazon Web Services Systems Manager is the operations hub for your Amazon Web * Services applications and resources and a secure end-to-end management solution * for hybrid cloud environments that enables safe and secure operations at * scale.

This reference is intended to be used with the Amazon Web * Services Systems Manager User Guide. To get started, see Setting * up Amazon Web Services Systems Manager.

Related * resources

*/ class AWS_SSM_API SSMClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef SSMClientConfiguration ClientConfigurationType; typedef SSMEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SSMClient(const Aws::SSM::SSMClientConfiguration& clientConfiguration = Aws::SSM::SSMClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SSMClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::SSM::SSMClientConfiguration& clientConfiguration = Aws::SSM::SSMClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ SSMClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::SSM::SSMClientConfiguration& clientConfiguration = Aws::SSM::SSMClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SSMClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SSMClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ SSMClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~SSMClient(); /** *

Adds or overwrites one or more tags for the specified resource. Tags * are metadata that you can assign to your automations, documents, managed nodes, * maintenance windows, Parameter Store parameters, and patch baselines. Tags * enable you to categorize your resources in different ways, for example, by * purpose, owner, or environment. Each tag consists of a key and an optional * value, both of which you define. For example, you could define a set of tags for * your account's managed nodes that helps you track each node's owner and stack * level. For example:

  • Key=Owner,Value=DbAdmin

    *

  • Key=Owner,Value=SysAdmin

  • * Key=Owner,Value=Dev

  • * Key=Stack,Value=Production

  • * Key=Stack,Value=Pre-Production

  • * Key=Stack,Value=Test

Most resources can have a * maximum of 50 tags. Automations can have a maximum of 5 tags.

We * recommend that you devise a set of tag keys that meets your needs for each * resource type. Using a consistent set of tag keys makes it easier for you to * manage your resources. You can search and filter the resources based on the tags * you add. Tags don't have any semantic meaning to and are interpreted strictly as * a string of characters.

For more information about using tags with Amazon * Elastic Compute Cloud (Amazon EC2) instances, see Tagging * your Amazon EC2 resources in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::AddTagsToResourceOutcome AddTagsToResource(const Model::AddTagsToResourceRequest& request) const; /** * A Callable wrapper for AddTagsToResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddTagsToResourceOutcomeCallable AddTagsToResourceCallable(const AddTagsToResourceRequestT& request) const { return SubmitCallable(&SSMClient::AddTagsToResource, request); } /** * An Async wrapper for AddTagsToResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddTagsToResourceAsync(const AddTagsToResourceRequestT& request, const AddTagsToResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::AddTagsToResource, request, handler, context); } /** *

Associates a related item to a Systems Manager OpsCenter OpsItem. For * example, you can associate an Incident Manager incident or analysis with an * OpsItem. Incident Manager and OpsCenter are capabilities of Amazon Web Services * Systems Manager.

See Also:

AWS * API Reference

*/ virtual Model::AssociateOpsItemRelatedItemOutcome AssociateOpsItemRelatedItem(const Model::AssociateOpsItemRelatedItemRequest& request) const; /** * A Callable wrapper for AssociateOpsItemRelatedItem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateOpsItemRelatedItemOutcomeCallable AssociateOpsItemRelatedItemCallable(const AssociateOpsItemRelatedItemRequestT& request) const { return SubmitCallable(&SSMClient::AssociateOpsItemRelatedItem, request); } /** * An Async wrapper for AssociateOpsItemRelatedItem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateOpsItemRelatedItemAsync(const AssociateOpsItemRelatedItemRequestT& request, const AssociateOpsItemRelatedItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::AssociateOpsItemRelatedItem, request, handler, context); } /** *

Attempts to cancel the command specified by the Command ID. There is no * guarantee that the command will be terminated and the underlying process * stopped.

See Also:

AWS * API Reference

*/ virtual Model::CancelCommandOutcome CancelCommand(const Model::CancelCommandRequest& request) const; /** * A Callable wrapper for CancelCommand that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelCommandOutcomeCallable CancelCommandCallable(const CancelCommandRequestT& request) const { return SubmitCallable(&SSMClient::CancelCommand, request); } /** * An Async wrapper for CancelCommand that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelCommandAsync(const CancelCommandRequestT& request, const CancelCommandResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::CancelCommand, request, handler, context); } /** *

Stops a maintenance window execution that is already in progress and cancels * any tasks in the window that haven't already starting running. Tasks already in * progress will continue to completion.

See Also:

AWS * API Reference

*/ virtual Model::CancelMaintenanceWindowExecutionOutcome CancelMaintenanceWindowExecution(const Model::CancelMaintenanceWindowExecutionRequest& request) const; /** * A Callable wrapper for CancelMaintenanceWindowExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelMaintenanceWindowExecutionOutcomeCallable CancelMaintenanceWindowExecutionCallable(const CancelMaintenanceWindowExecutionRequestT& request) const { return SubmitCallable(&SSMClient::CancelMaintenanceWindowExecution, request); } /** * An Async wrapper for CancelMaintenanceWindowExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelMaintenanceWindowExecutionAsync(const CancelMaintenanceWindowExecutionRequestT& request, const CancelMaintenanceWindowExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::CancelMaintenanceWindowExecution, request, handler, context); } /** *

Generates an activation code and activation ID you can use to register your * on-premises servers, edge devices, or virtual machine (VM) with Amazon Web * Services Systems Manager. Registering these machines with Systems Manager makes * it possible to manage them using Systems Manager capabilities. You use the * activation code and ID when installing SSM Agent on machines in your hybrid * environment. For more information about requirements for managing on-premises * machines using Systems Manager, see Setting * up Amazon Web Services Systems Manager for hybrid environments in the * Amazon Web Services Systems Manager User Guide.

Amazon * Elastic Compute Cloud (Amazon EC2) instances, edge devices, and on-premises * servers and VMs that are configured for Systems Manager are all called * managed nodes.

See Also:

AWS * API Reference

*/ virtual Model::CreateActivationOutcome CreateActivation(const Model::CreateActivationRequest& request) const; /** * A Callable wrapper for CreateActivation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateActivationOutcomeCallable CreateActivationCallable(const CreateActivationRequestT& request) const { return SubmitCallable(&SSMClient::CreateActivation, request); } /** * An Async wrapper for CreateActivation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateActivationAsync(const CreateActivationRequestT& request, const CreateActivationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::CreateActivation, request, handler, context); } /** *

A State Manager association defines the state that you want to maintain on * your managed nodes. For example, an association can specify that anti-virus * software must be installed and running on your managed nodes, or that certain * ports must be closed. For static targets, the association specifies a schedule * for when the configuration is reapplied. For dynamic targets, such as an Amazon * Web Services resource group or an Amazon Web Services autoscaling group, State * Manager, a capability of Amazon Web Services Systems Manager applies the * configuration when new managed nodes are added to the group. The association * also specifies actions to take when applying the configuration. For example, an * association for anti-virus software might run once a day. If the software isn't * installed, then State Manager installs it. If the software is installed, but the * service isn't running, then the association might instruct State Manager to * start the service.

See Also:

AWS * API Reference

*/ virtual Model::CreateAssociationOutcome CreateAssociation(const Model::CreateAssociationRequest& request) const; /** * A Callable wrapper for CreateAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAssociationOutcomeCallable CreateAssociationCallable(const CreateAssociationRequestT& request) const { return SubmitCallable(&SSMClient::CreateAssociation, request); } /** * An Async wrapper for CreateAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAssociationAsync(const CreateAssociationRequestT& request, const CreateAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::CreateAssociation, request, handler, context); } /** *

Associates the specified Amazon Web Services Systems Manager document (SSM * document) with the specified managed nodes or targets.

When you associate * a document with one or more managed nodes using IDs or tags, Amazon Web Services * Systems Manager Agent (SSM Agent) running on the managed node processes the * document and configures the node as specified.

If you associate a * document with a managed node that already has an associated document, the system * returns the AssociationAlreadyExists exception.

See Also:

AWS * API Reference

*/ virtual Model::CreateAssociationBatchOutcome CreateAssociationBatch(const Model::CreateAssociationBatchRequest& request) const; /** * A Callable wrapper for CreateAssociationBatch that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAssociationBatchOutcomeCallable CreateAssociationBatchCallable(const CreateAssociationBatchRequestT& request) const { return SubmitCallable(&SSMClient::CreateAssociationBatch, request); } /** * An Async wrapper for CreateAssociationBatch that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAssociationBatchAsync(const CreateAssociationBatchRequestT& request, const CreateAssociationBatchResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::CreateAssociationBatch, request, handler, context); } /** *

Creates a Amazon Web Services Systems Manager (SSM document). An SSM document * defines the actions that Systems Manager performs on your managed nodes. For * more information about SSM documents, including information about supported * schemas, features, and syntax, see Amazon * Web Services Systems Manager Documents in the Amazon Web Services Systems * Manager User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateDocumentOutcome CreateDocument(const Model::CreateDocumentRequest& request) const; /** * A Callable wrapper for CreateDocument that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDocumentOutcomeCallable CreateDocumentCallable(const CreateDocumentRequestT& request) const { return SubmitCallable(&SSMClient::CreateDocument, request); } /** * An Async wrapper for CreateDocument that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDocumentAsync(const CreateDocumentRequestT& request, const CreateDocumentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::CreateDocument, request, handler, context); } /** *

Creates a new maintenance window.

The value you specify for * Duration determines the specific end time for the maintenance * window based on the time it begins. No maintenance window tasks are permitted to * start after the resulting endtime minus the number of hours you specify for * Cutoff. For example, if the maintenance window starts at 3 PM, the * duration is three hours, and the value you specify for Cutoff is * one hour, no maintenance window tasks can start after 5 PM.

*

See Also:

AWS * API Reference

*/ virtual Model::CreateMaintenanceWindowOutcome CreateMaintenanceWindow(const Model::CreateMaintenanceWindowRequest& request) const; /** * A Callable wrapper for CreateMaintenanceWindow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateMaintenanceWindowOutcomeCallable CreateMaintenanceWindowCallable(const CreateMaintenanceWindowRequestT& request) const { return SubmitCallable(&SSMClient::CreateMaintenanceWindow, request); } /** * An Async wrapper for CreateMaintenanceWindow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateMaintenanceWindowAsync(const CreateMaintenanceWindowRequestT& request, const CreateMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::CreateMaintenanceWindow, request, handler, context); } /** *

Creates a new OpsItem. You must have permission in Identity and Access * Management (IAM) to create a new OpsItem. For more information, see Set * up OpsCenter in the Amazon Web Services Systems Manager User * Guide.

Operations engineers and IT professionals use Amazon Web * Services Systems Manager OpsCenter to view, investigate, and remediate * operational issues impacting the performance and health of their Amazon Web * Services resources. For more information, see Amazon * Web Services Systems Manager OpsCenter in the Amazon Web Services Systems * Manager User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateOpsItemOutcome CreateOpsItem(const Model::CreateOpsItemRequest& request) const; /** * A Callable wrapper for CreateOpsItem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateOpsItemOutcomeCallable CreateOpsItemCallable(const CreateOpsItemRequestT& request) const { return SubmitCallable(&SSMClient::CreateOpsItem, request); } /** * An Async wrapper for CreateOpsItem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateOpsItemAsync(const CreateOpsItemRequestT& request, const CreateOpsItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::CreateOpsItem, request, handler, context); } /** *

If you create a new application in Application Manager, Amazon Web Services * Systems Manager calls this API operation to specify information about the new * application, including the application type.

See Also:

AWS * API Reference

*/ virtual Model::CreateOpsMetadataOutcome CreateOpsMetadata(const Model::CreateOpsMetadataRequest& request) const; /** * A Callable wrapper for CreateOpsMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateOpsMetadataOutcomeCallable CreateOpsMetadataCallable(const CreateOpsMetadataRequestT& request) const { return SubmitCallable(&SSMClient::CreateOpsMetadata, request); } /** * An Async wrapper for CreateOpsMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateOpsMetadataAsync(const CreateOpsMetadataRequestT& request, const CreateOpsMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::CreateOpsMetadata, request, handler, context); } /** *

Creates a patch baseline.

For information about valid key-value * pairs in PatchFilters for each supported operating system type, see * PatchFilter.

See Also:

AWS * API Reference

*/ virtual Model::CreatePatchBaselineOutcome CreatePatchBaseline(const Model::CreatePatchBaselineRequest& request) const; /** * A Callable wrapper for CreatePatchBaseline that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePatchBaselineOutcomeCallable CreatePatchBaselineCallable(const CreatePatchBaselineRequestT& request) const { return SubmitCallable(&SSMClient::CreatePatchBaseline, request); } /** * An Async wrapper for CreatePatchBaseline that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePatchBaselineAsync(const CreatePatchBaselineRequestT& request, const CreatePatchBaselineResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::CreatePatchBaseline, request, handler, context); } /** *

A resource data sync helps you view data from multiple sources in a single * location. Amazon Web Services Systems Manager offers two types of resource data * sync: SyncToDestination and SyncFromSource.

You * can configure Systems Manager Inventory to use the * SyncToDestination type to synchronize Inventory data from multiple * Amazon Web Services Regions to a single Amazon Simple Storage Service (Amazon * S3) bucket. For more information, see Configuring * resource data sync for Inventory in the Amazon Web Services Systems * Manager User Guide.

You can configure Systems Manager Explorer to use * the SyncFromSource type to synchronize operational work items * (OpsItems) and operational data (OpsData) from multiple Amazon Web Services * Regions to a single Amazon S3 bucket. This type can synchronize OpsItems and * OpsData from multiple Amazon Web Services accounts and Amazon Web Services * Regions or EntireOrganization by using Organizations. For more * information, see Setting * up Systems Manager Explorer to display data from multiple accounts and * Regions in the Amazon Web Services Systems Manager User Guide.

*

A resource data sync is an asynchronous operation that returns immediately. * After a successful initial sync is completed, the system continuously syncs * data. To check the status of a sync, use the ListResourceDataSync.

*

By default, data isn't encrypted in Amazon S3. We strongly recommend * that you enable encryption in Amazon S3 to ensure secure data storage. We also * recommend that you secure access to the Amazon S3 bucket by creating a * restrictive bucket policy.

See Also:

AWS * API Reference

*/ virtual Model::CreateResourceDataSyncOutcome CreateResourceDataSync(const Model::CreateResourceDataSyncRequest& request) const; /** * A Callable wrapper for CreateResourceDataSync that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateResourceDataSyncOutcomeCallable CreateResourceDataSyncCallable(const CreateResourceDataSyncRequestT& request) const { return SubmitCallable(&SSMClient::CreateResourceDataSync, request); } /** * An Async wrapper for CreateResourceDataSync that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateResourceDataSyncAsync(const CreateResourceDataSyncRequestT& request, const CreateResourceDataSyncResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::CreateResourceDataSync, request, handler, context); } /** *

Deletes an activation. You aren't required to delete an activation. If you * delete an activation, you can no longer use it to register additional managed * nodes. Deleting an activation doesn't de-register managed nodes. You must * manually de-register managed nodes.

See Also:

AWS * API Reference

*/ virtual Model::DeleteActivationOutcome DeleteActivation(const Model::DeleteActivationRequest& request) const; /** * A Callable wrapper for DeleteActivation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteActivationOutcomeCallable DeleteActivationCallable(const DeleteActivationRequestT& request) const { return SubmitCallable(&SSMClient::DeleteActivation, request); } /** * An Async wrapper for DeleteActivation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteActivationAsync(const DeleteActivationRequestT& request, const DeleteActivationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DeleteActivation, request, handler, context); } /** *

Disassociates the specified Amazon Web Services Systems Manager document (SSM * document) from the specified managed node. If you created the association by * using the Targets parameter, then you must delete the association * by using the association ID.

When you disassociate a document from a * managed node, it doesn't change the configuration of the node. To change the * configuration state of a managed node after you disassociate a document, you * must create a new document with the desired configuration and associate it with * the node.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAssociationOutcome DeleteAssociation(const Model::DeleteAssociationRequest& request) const; /** * A Callable wrapper for DeleteAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAssociationOutcomeCallable DeleteAssociationCallable(const DeleteAssociationRequestT& request) const { return SubmitCallable(&SSMClient::DeleteAssociation, request); } /** * An Async wrapper for DeleteAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAssociationAsync(const DeleteAssociationRequestT& request, const DeleteAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DeleteAssociation, request, handler, context); } /** *

Deletes the Amazon Web Services Systems Manager document (SSM document) and * all managed node associations to the document.

Before you delete the * document, we recommend that you use DeleteAssociation to disassociate all * managed nodes that are associated with the document.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteDocumentOutcome DeleteDocument(const Model::DeleteDocumentRequest& request) const; /** * A Callable wrapper for DeleteDocument that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDocumentOutcomeCallable DeleteDocumentCallable(const DeleteDocumentRequestT& request) const { return SubmitCallable(&SSMClient::DeleteDocument, request); } /** * An Async wrapper for DeleteDocument that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDocumentAsync(const DeleteDocumentRequestT& request, const DeleteDocumentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DeleteDocument, request, handler, context); } /** *

Delete a custom inventory type or the data associated with a custom Inventory * type. Deleting a custom inventory type is also referred to as deleting a custom * inventory schema.

See Also:

AWS * API Reference

*/ virtual Model::DeleteInventoryOutcome DeleteInventory(const Model::DeleteInventoryRequest& request) const; /** * A Callable wrapper for DeleteInventory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteInventoryOutcomeCallable DeleteInventoryCallable(const DeleteInventoryRequestT& request) const { return SubmitCallable(&SSMClient::DeleteInventory, request); } /** * An Async wrapper for DeleteInventory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteInventoryAsync(const DeleteInventoryRequestT& request, const DeleteInventoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DeleteInventory, request, handler, context); } /** *

Deletes a maintenance window.

See Also:

AWS * API Reference

*/ virtual Model::DeleteMaintenanceWindowOutcome DeleteMaintenanceWindow(const Model::DeleteMaintenanceWindowRequest& request) const; /** * A Callable wrapper for DeleteMaintenanceWindow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteMaintenanceWindowOutcomeCallable DeleteMaintenanceWindowCallable(const DeleteMaintenanceWindowRequestT& request) const { return SubmitCallable(&SSMClient::DeleteMaintenanceWindow, request); } /** * An Async wrapper for DeleteMaintenanceWindow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteMaintenanceWindowAsync(const DeleteMaintenanceWindowRequestT& request, const DeleteMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DeleteMaintenanceWindow, request, handler, context); } /** *

Delete OpsMetadata related to an application.

See Also:

AWS * API Reference

*/ virtual Model::DeleteOpsMetadataOutcome DeleteOpsMetadata(const Model::DeleteOpsMetadataRequest& request) const; /** * A Callable wrapper for DeleteOpsMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteOpsMetadataOutcomeCallable DeleteOpsMetadataCallable(const DeleteOpsMetadataRequestT& request) const { return SubmitCallable(&SSMClient::DeleteOpsMetadata, request); } /** * An Async wrapper for DeleteOpsMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteOpsMetadataAsync(const DeleteOpsMetadataRequestT& request, const DeleteOpsMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DeleteOpsMetadata, request, handler, context); } /** *

Delete a parameter from the system. After deleting a parameter, wait for at * least 30 seconds to create a parameter with the same name.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteParameterOutcome DeleteParameter(const Model::DeleteParameterRequest& request) const; /** * A Callable wrapper for DeleteParameter that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteParameterOutcomeCallable DeleteParameterCallable(const DeleteParameterRequestT& request) const { return SubmitCallable(&SSMClient::DeleteParameter, request); } /** * An Async wrapper for DeleteParameter that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteParameterAsync(const DeleteParameterRequestT& request, const DeleteParameterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DeleteParameter, request, handler, context); } /** *

Delete a list of parameters. After deleting a parameter, wait for at least 30 * seconds to create a parameter with the same name.

See Also:

AWS * API Reference

*/ virtual Model::DeleteParametersOutcome DeleteParameters(const Model::DeleteParametersRequest& request) const; /** * A Callable wrapper for DeleteParameters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteParametersOutcomeCallable DeleteParametersCallable(const DeleteParametersRequestT& request) const { return SubmitCallable(&SSMClient::DeleteParameters, request); } /** * An Async wrapper for DeleteParameters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteParametersAsync(const DeleteParametersRequestT& request, const DeleteParametersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DeleteParameters, request, handler, context); } /** *

Deletes a patch baseline.

See Also:

AWS * API Reference

*/ virtual Model::DeletePatchBaselineOutcome DeletePatchBaseline(const Model::DeletePatchBaselineRequest& request) const; /** * A Callable wrapper for DeletePatchBaseline that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePatchBaselineOutcomeCallable DeletePatchBaselineCallable(const DeletePatchBaselineRequestT& request) const { return SubmitCallable(&SSMClient::DeletePatchBaseline, request); } /** * An Async wrapper for DeletePatchBaseline that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePatchBaselineAsync(const DeletePatchBaselineRequestT& request, const DeletePatchBaselineResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DeletePatchBaseline, request, handler, context); } /** *

Deletes a resource data sync configuration. After the configuration is * deleted, changes to data on managed nodes are no longer synced to or from the * target. Deleting a sync configuration doesn't delete data.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteResourceDataSyncOutcome DeleteResourceDataSync(const Model::DeleteResourceDataSyncRequest& request) const; /** * A Callable wrapper for DeleteResourceDataSync that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteResourceDataSyncOutcomeCallable DeleteResourceDataSyncCallable(const DeleteResourceDataSyncRequestT& request) const { return SubmitCallable(&SSMClient::DeleteResourceDataSync, request); } /** * An Async wrapper for DeleteResourceDataSync that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteResourceDataSyncAsync(const DeleteResourceDataSyncRequestT& request, const DeleteResourceDataSyncResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DeleteResourceDataSync, request, handler, context); } /** *

Deletes a Systems Manager resource policy. A resource policy helps you to * define the IAM entity (for example, an Amazon Web Services account) that can * manage your Systems Manager resources. Currently, OpsItemGroup is * the only resource that supports Systems Manager resource policies. The resource * policy for OpsItemGroup enables Amazon Web Services accounts to * view and interact with OpsCenter operational work items * (OpsItems).

See Also:

AWS * API Reference

*/ virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const; /** * A Callable wrapper for DeleteResourcePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const { return SubmitCallable(&SSMClient::DeleteResourcePolicy, request); } /** * An Async wrapper for DeleteResourcePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DeleteResourcePolicy, request, handler, context); } /** *

Removes the server or virtual machine from the list of registered servers. * You can reregister the node again at any time. If you don't plan to use Run * Command on the server, we suggest uninstalling SSM Agent first.

See * Also:

AWS * API Reference

*/ virtual Model::DeregisterManagedInstanceOutcome DeregisterManagedInstance(const Model::DeregisterManagedInstanceRequest& request) const; /** * A Callable wrapper for DeregisterManagedInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterManagedInstanceOutcomeCallable DeregisterManagedInstanceCallable(const DeregisterManagedInstanceRequestT& request) const { return SubmitCallable(&SSMClient::DeregisterManagedInstance, request); } /** * An Async wrapper for DeregisterManagedInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterManagedInstanceAsync(const DeregisterManagedInstanceRequestT& request, const DeregisterManagedInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DeregisterManagedInstance, request, handler, context); } /** *

Removes a patch group from a patch baseline.

See Also:

AWS * API Reference

*/ virtual Model::DeregisterPatchBaselineForPatchGroupOutcome DeregisterPatchBaselineForPatchGroup(const Model::DeregisterPatchBaselineForPatchGroupRequest& request) const; /** * A Callable wrapper for DeregisterPatchBaselineForPatchGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterPatchBaselineForPatchGroupOutcomeCallable DeregisterPatchBaselineForPatchGroupCallable(const DeregisterPatchBaselineForPatchGroupRequestT& request) const { return SubmitCallable(&SSMClient::DeregisterPatchBaselineForPatchGroup, request); } /** * An Async wrapper for DeregisterPatchBaselineForPatchGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterPatchBaselineForPatchGroupAsync(const DeregisterPatchBaselineForPatchGroupRequestT& request, const DeregisterPatchBaselineForPatchGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DeregisterPatchBaselineForPatchGroup, request, handler, context); } /** *

Removes a target from a maintenance window.

See Also:

AWS * API Reference

*/ virtual Model::DeregisterTargetFromMaintenanceWindowOutcome DeregisterTargetFromMaintenanceWindow(const Model::DeregisterTargetFromMaintenanceWindowRequest& request) const; /** * A Callable wrapper for DeregisterTargetFromMaintenanceWindow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterTargetFromMaintenanceWindowOutcomeCallable DeregisterTargetFromMaintenanceWindowCallable(const DeregisterTargetFromMaintenanceWindowRequestT& request) const { return SubmitCallable(&SSMClient::DeregisterTargetFromMaintenanceWindow, request); } /** * An Async wrapper for DeregisterTargetFromMaintenanceWindow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterTargetFromMaintenanceWindowAsync(const DeregisterTargetFromMaintenanceWindowRequestT& request, const DeregisterTargetFromMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DeregisterTargetFromMaintenanceWindow, request, handler, context); } /** *

Removes a task from a maintenance window.

See Also:

AWS * API Reference

*/ virtual Model::DeregisterTaskFromMaintenanceWindowOutcome DeregisterTaskFromMaintenanceWindow(const Model::DeregisterTaskFromMaintenanceWindowRequest& request) const; /** * A Callable wrapper for DeregisterTaskFromMaintenanceWindow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterTaskFromMaintenanceWindowOutcomeCallable DeregisterTaskFromMaintenanceWindowCallable(const DeregisterTaskFromMaintenanceWindowRequestT& request) const { return SubmitCallable(&SSMClient::DeregisterTaskFromMaintenanceWindow, request); } /** * An Async wrapper for DeregisterTaskFromMaintenanceWindow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterTaskFromMaintenanceWindowAsync(const DeregisterTaskFromMaintenanceWindowRequestT& request, const DeregisterTaskFromMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DeregisterTaskFromMaintenanceWindow, request, handler, context); } /** *

Describes details about the activation, such as the date and time the * activation was created, its expiration date, the Identity and Access Management * (IAM) role assigned to the managed nodes in the activation, and the number of * nodes registered by using this activation.

See Also:

AWS * API Reference

*/ virtual Model::DescribeActivationsOutcome DescribeActivations(const Model::DescribeActivationsRequest& request) const; /** * A Callable wrapper for DescribeActivations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeActivationsOutcomeCallable DescribeActivationsCallable(const DescribeActivationsRequestT& request) const { return SubmitCallable(&SSMClient::DescribeActivations, request); } /** * An Async wrapper for DescribeActivations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeActivationsAsync(const DescribeActivationsRequestT& request, const DescribeActivationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeActivations, request, handler, context); } /** *

Describes the association for the specified target or managed node. If you * created the association by using the Targets parameter, then you * must retrieve the association by using the association ID.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeAssociationOutcome DescribeAssociation(const Model::DescribeAssociationRequest& request) const; /** * A Callable wrapper for DescribeAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAssociationOutcomeCallable DescribeAssociationCallable(const DescribeAssociationRequestT& request) const { return SubmitCallable(&SSMClient::DescribeAssociation, request); } /** * An Async wrapper for DescribeAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAssociationAsync(const DescribeAssociationRequestT& request, const DescribeAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeAssociation, request, handler, context); } /** *

Views information about a specific execution of a specific * association.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAssociationExecutionTargetsOutcome DescribeAssociationExecutionTargets(const Model::DescribeAssociationExecutionTargetsRequest& request) const; /** * A Callable wrapper for DescribeAssociationExecutionTargets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAssociationExecutionTargetsOutcomeCallable DescribeAssociationExecutionTargetsCallable(const DescribeAssociationExecutionTargetsRequestT& request) const { return SubmitCallable(&SSMClient::DescribeAssociationExecutionTargets, request); } /** * An Async wrapper for DescribeAssociationExecutionTargets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAssociationExecutionTargetsAsync(const DescribeAssociationExecutionTargetsRequestT& request, const DescribeAssociationExecutionTargetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeAssociationExecutionTargets, request, handler, context); } /** *

Views all executions for a specific association ID.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeAssociationExecutionsOutcome DescribeAssociationExecutions(const Model::DescribeAssociationExecutionsRequest& request) const; /** * A Callable wrapper for DescribeAssociationExecutions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAssociationExecutionsOutcomeCallable DescribeAssociationExecutionsCallable(const DescribeAssociationExecutionsRequestT& request) const { return SubmitCallable(&SSMClient::DescribeAssociationExecutions, request); } /** * An Async wrapper for DescribeAssociationExecutions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAssociationExecutionsAsync(const DescribeAssociationExecutionsRequestT& request, const DescribeAssociationExecutionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeAssociationExecutions, request, handler, context); } /** *

Provides details about all active and terminated Automation * executions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAutomationExecutionsOutcome DescribeAutomationExecutions(const Model::DescribeAutomationExecutionsRequest& request) const; /** * A Callable wrapper for DescribeAutomationExecutions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAutomationExecutionsOutcomeCallable DescribeAutomationExecutionsCallable(const DescribeAutomationExecutionsRequestT& request) const { return SubmitCallable(&SSMClient::DescribeAutomationExecutions, request); } /** * An Async wrapper for DescribeAutomationExecutions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAutomationExecutionsAsync(const DescribeAutomationExecutionsRequestT& request, const DescribeAutomationExecutionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeAutomationExecutions, request, handler, context); } /** *

Information about all active and terminated step executions in an Automation * workflow.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAutomationStepExecutionsOutcome DescribeAutomationStepExecutions(const Model::DescribeAutomationStepExecutionsRequest& request) const; /** * A Callable wrapper for DescribeAutomationStepExecutions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAutomationStepExecutionsOutcomeCallable DescribeAutomationStepExecutionsCallable(const DescribeAutomationStepExecutionsRequestT& request) const { return SubmitCallable(&SSMClient::DescribeAutomationStepExecutions, request); } /** * An Async wrapper for DescribeAutomationStepExecutions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAutomationStepExecutionsAsync(const DescribeAutomationStepExecutionsRequestT& request, const DescribeAutomationStepExecutionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeAutomationStepExecutions, request, handler, context); } /** *

Lists all patches eligible to be included in a patch baseline.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeAvailablePatchesOutcome DescribeAvailablePatches(const Model::DescribeAvailablePatchesRequest& request) const; /** * A Callable wrapper for DescribeAvailablePatches that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAvailablePatchesOutcomeCallable DescribeAvailablePatchesCallable(const DescribeAvailablePatchesRequestT& request) const { return SubmitCallable(&SSMClient::DescribeAvailablePatches, request); } /** * An Async wrapper for DescribeAvailablePatches that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAvailablePatchesAsync(const DescribeAvailablePatchesRequestT& request, const DescribeAvailablePatchesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeAvailablePatches, request, handler, context); } /** *

Describes the specified Amazon Web Services Systems Manager document (SSM * document).

See Also:

AWS * API Reference

*/ virtual Model::DescribeDocumentOutcome DescribeDocument(const Model::DescribeDocumentRequest& request) const; /** * A Callable wrapper for DescribeDocument that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDocumentOutcomeCallable DescribeDocumentCallable(const DescribeDocumentRequestT& request) const { return SubmitCallable(&SSMClient::DescribeDocument, request); } /** * An Async wrapper for DescribeDocument that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDocumentAsync(const DescribeDocumentRequestT& request, const DescribeDocumentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeDocument, request, handler, context); } /** *

Describes the permissions for a Amazon Web Services Systems Manager document * (SSM document). If you created the document, you are the owner. If a document is * shared, it can either be shared privately (by specifying a user's Amazon Web * Services account ID) or publicly (All).

See Also:

AWS * API Reference

*/ virtual Model::DescribeDocumentPermissionOutcome DescribeDocumentPermission(const Model::DescribeDocumentPermissionRequest& request) const; /** * A Callable wrapper for DescribeDocumentPermission that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDocumentPermissionOutcomeCallable DescribeDocumentPermissionCallable(const DescribeDocumentPermissionRequestT& request) const { return SubmitCallable(&SSMClient::DescribeDocumentPermission, request); } /** * An Async wrapper for DescribeDocumentPermission that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDocumentPermissionAsync(const DescribeDocumentPermissionRequestT& request, const DescribeDocumentPermissionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeDocumentPermission, request, handler, context); } /** *

All associations for the managed node(s).

See Also:

AWS * API Reference

*/ virtual Model::DescribeEffectiveInstanceAssociationsOutcome DescribeEffectiveInstanceAssociations(const Model::DescribeEffectiveInstanceAssociationsRequest& request) const; /** * A Callable wrapper for DescribeEffectiveInstanceAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEffectiveInstanceAssociationsOutcomeCallable DescribeEffectiveInstanceAssociationsCallable(const DescribeEffectiveInstanceAssociationsRequestT& request) const { return SubmitCallable(&SSMClient::DescribeEffectiveInstanceAssociations, request); } /** * An Async wrapper for DescribeEffectiveInstanceAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEffectiveInstanceAssociationsAsync(const DescribeEffectiveInstanceAssociationsRequestT& request, const DescribeEffectiveInstanceAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeEffectiveInstanceAssociations, request, handler, context); } /** *

Retrieves the current effective patches (the patch and the approval state) * for the specified patch baseline. Applies to patch baselines for Windows * only.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEffectivePatchesForPatchBaselineOutcome DescribeEffectivePatchesForPatchBaseline(const Model::DescribeEffectivePatchesForPatchBaselineRequest& request) const; /** * A Callable wrapper for DescribeEffectivePatchesForPatchBaseline that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEffectivePatchesForPatchBaselineOutcomeCallable DescribeEffectivePatchesForPatchBaselineCallable(const DescribeEffectivePatchesForPatchBaselineRequestT& request) const { return SubmitCallable(&SSMClient::DescribeEffectivePatchesForPatchBaseline, request); } /** * An Async wrapper for DescribeEffectivePatchesForPatchBaseline that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEffectivePatchesForPatchBaselineAsync(const DescribeEffectivePatchesForPatchBaselineRequestT& request, const DescribeEffectivePatchesForPatchBaselineResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeEffectivePatchesForPatchBaseline, request, handler, context); } /** *

The status of the associations for the managed node(s).

See * Also:

AWS * API Reference

*/ virtual Model::DescribeInstanceAssociationsStatusOutcome DescribeInstanceAssociationsStatus(const Model::DescribeInstanceAssociationsStatusRequest& request) const; /** * A Callable wrapper for DescribeInstanceAssociationsStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInstanceAssociationsStatusOutcomeCallable DescribeInstanceAssociationsStatusCallable(const DescribeInstanceAssociationsStatusRequestT& request) const { return SubmitCallable(&SSMClient::DescribeInstanceAssociationsStatus, request); } /** * An Async wrapper for DescribeInstanceAssociationsStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInstanceAssociationsStatusAsync(const DescribeInstanceAssociationsStatusRequestT& request, const DescribeInstanceAssociationsStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeInstanceAssociationsStatus, request, handler, context); } /** *

Provides information about one or more of your managed nodes, including the * operating system platform, SSM Agent version, association status, and IP * address. This operation does not return information for nodes that are either * Stopped or Terminated.

If you specify one or more node IDs, the operation * returns information for those managed nodes. If you don't specify node IDs, it * returns information for all your managed nodes. If you specify a node ID that * isn't valid or a node that you don't own, you receive an error.

*

The IamRole field returned for this API operation is the * Identity and Access Management (IAM) role assigned to on-premises managed nodes. * This operation does not return the IAM role for EC2 instances.

*

See Also:

AWS * API Reference

*/ virtual Model::DescribeInstanceInformationOutcome DescribeInstanceInformation(const Model::DescribeInstanceInformationRequest& request) const; /** * A Callable wrapper for DescribeInstanceInformation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInstanceInformationOutcomeCallable DescribeInstanceInformationCallable(const DescribeInstanceInformationRequestT& request) const { return SubmitCallable(&SSMClient::DescribeInstanceInformation, request); } /** * An Async wrapper for DescribeInstanceInformation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInstanceInformationAsync(const DescribeInstanceInformationRequestT& request, const DescribeInstanceInformationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeInstanceInformation, request, handler, context); } /** *

Retrieves the high-level patch state of one or more managed * nodes.

See Also:

AWS * API Reference

*/ virtual Model::DescribeInstancePatchStatesOutcome DescribeInstancePatchStates(const Model::DescribeInstancePatchStatesRequest& request) const; /** * A Callable wrapper for DescribeInstancePatchStates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInstancePatchStatesOutcomeCallable DescribeInstancePatchStatesCallable(const DescribeInstancePatchStatesRequestT& request) const { return SubmitCallable(&SSMClient::DescribeInstancePatchStates, request); } /** * An Async wrapper for DescribeInstancePatchStates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInstancePatchStatesAsync(const DescribeInstancePatchStatesRequestT& request, const DescribeInstancePatchStatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeInstancePatchStates, request, handler, context); } /** *

Retrieves the high-level patch state for the managed nodes in the specified * patch group.

See Also:

AWS * API Reference

*/ virtual Model::DescribeInstancePatchStatesForPatchGroupOutcome DescribeInstancePatchStatesForPatchGroup(const Model::DescribeInstancePatchStatesForPatchGroupRequest& request) const; /** * A Callable wrapper for DescribeInstancePatchStatesForPatchGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInstancePatchStatesForPatchGroupOutcomeCallable DescribeInstancePatchStatesForPatchGroupCallable(const DescribeInstancePatchStatesForPatchGroupRequestT& request) const { return SubmitCallable(&SSMClient::DescribeInstancePatchStatesForPatchGroup, request); } /** * An Async wrapper for DescribeInstancePatchStatesForPatchGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInstancePatchStatesForPatchGroupAsync(const DescribeInstancePatchStatesForPatchGroupRequestT& request, const DescribeInstancePatchStatesForPatchGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeInstancePatchStatesForPatchGroup, request, handler, context); } /** *

Retrieves information about the patches on the specified managed node and * their state relative to the patch baseline being used for the * node.

See Also:

AWS * API Reference

*/ virtual Model::DescribeInstancePatchesOutcome DescribeInstancePatches(const Model::DescribeInstancePatchesRequest& request) const; /** * A Callable wrapper for DescribeInstancePatches that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInstancePatchesOutcomeCallable DescribeInstancePatchesCallable(const DescribeInstancePatchesRequestT& request) const { return SubmitCallable(&SSMClient::DescribeInstancePatches, request); } /** * An Async wrapper for DescribeInstancePatches that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInstancePatchesAsync(const DescribeInstancePatchesRequestT& request, const DescribeInstancePatchesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeInstancePatches, request, handler, context); } /** *

Describes a specific delete inventory operation.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeInventoryDeletionsOutcome DescribeInventoryDeletions(const Model::DescribeInventoryDeletionsRequest& request) const; /** * A Callable wrapper for DescribeInventoryDeletions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInventoryDeletionsOutcomeCallable DescribeInventoryDeletionsCallable(const DescribeInventoryDeletionsRequestT& request) const { return SubmitCallable(&SSMClient::DescribeInventoryDeletions, request); } /** * An Async wrapper for DescribeInventoryDeletions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInventoryDeletionsAsync(const DescribeInventoryDeletionsRequestT& request, const DescribeInventoryDeletionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeInventoryDeletions, request, handler, context); } /** *

Retrieves the individual task executions (one per target) for a particular * task run as part of a maintenance window execution.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeMaintenanceWindowExecutionTaskInvocationsOutcome DescribeMaintenanceWindowExecutionTaskInvocations(const Model::DescribeMaintenanceWindowExecutionTaskInvocationsRequest& request) const; /** * A Callable wrapper for DescribeMaintenanceWindowExecutionTaskInvocations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMaintenanceWindowExecutionTaskInvocationsOutcomeCallable DescribeMaintenanceWindowExecutionTaskInvocationsCallable(const DescribeMaintenanceWindowExecutionTaskInvocationsRequestT& request) const { return SubmitCallable(&SSMClient::DescribeMaintenanceWindowExecutionTaskInvocations, request); } /** * An Async wrapper for DescribeMaintenanceWindowExecutionTaskInvocations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMaintenanceWindowExecutionTaskInvocationsAsync(const DescribeMaintenanceWindowExecutionTaskInvocationsRequestT& request, const DescribeMaintenanceWindowExecutionTaskInvocationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeMaintenanceWindowExecutionTaskInvocations, request, handler, context); } /** *

For a given maintenance window execution, lists the tasks that were * run.

See Also:

AWS * API Reference

*/ virtual Model::DescribeMaintenanceWindowExecutionTasksOutcome DescribeMaintenanceWindowExecutionTasks(const Model::DescribeMaintenanceWindowExecutionTasksRequest& request) const; /** * A Callable wrapper for DescribeMaintenanceWindowExecutionTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMaintenanceWindowExecutionTasksOutcomeCallable DescribeMaintenanceWindowExecutionTasksCallable(const DescribeMaintenanceWindowExecutionTasksRequestT& request) const { return SubmitCallable(&SSMClient::DescribeMaintenanceWindowExecutionTasks, request); } /** * An Async wrapper for DescribeMaintenanceWindowExecutionTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMaintenanceWindowExecutionTasksAsync(const DescribeMaintenanceWindowExecutionTasksRequestT& request, const DescribeMaintenanceWindowExecutionTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeMaintenanceWindowExecutionTasks, request, handler, context); } /** *

Lists the executions of a maintenance window. This includes information about * when the maintenance window was scheduled to be active, and information about * tasks registered and run with the maintenance window.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeMaintenanceWindowExecutionsOutcome DescribeMaintenanceWindowExecutions(const Model::DescribeMaintenanceWindowExecutionsRequest& request) const; /** * A Callable wrapper for DescribeMaintenanceWindowExecutions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMaintenanceWindowExecutionsOutcomeCallable DescribeMaintenanceWindowExecutionsCallable(const DescribeMaintenanceWindowExecutionsRequestT& request) const { return SubmitCallable(&SSMClient::DescribeMaintenanceWindowExecutions, request); } /** * An Async wrapper for DescribeMaintenanceWindowExecutions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMaintenanceWindowExecutionsAsync(const DescribeMaintenanceWindowExecutionsRequestT& request, const DescribeMaintenanceWindowExecutionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeMaintenanceWindowExecutions, request, handler, context); } /** *

Retrieves information about upcoming executions of a maintenance * window.

See Also:

AWS * API Reference

*/ virtual Model::DescribeMaintenanceWindowScheduleOutcome DescribeMaintenanceWindowSchedule(const Model::DescribeMaintenanceWindowScheduleRequest& request) const; /** * A Callable wrapper for DescribeMaintenanceWindowSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMaintenanceWindowScheduleOutcomeCallable DescribeMaintenanceWindowScheduleCallable(const DescribeMaintenanceWindowScheduleRequestT& request) const { return SubmitCallable(&SSMClient::DescribeMaintenanceWindowSchedule, request); } /** * An Async wrapper for DescribeMaintenanceWindowSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMaintenanceWindowScheduleAsync(const DescribeMaintenanceWindowScheduleRequestT& request, const DescribeMaintenanceWindowScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeMaintenanceWindowSchedule, request, handler, context); } /** *

Lists the targets registered with the maintenance window.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeMaintenanceWindowTargetsOutcome DescribeMaintenanceWindowTargets(const Model::DescribeMaintenanceWindowTargetsRequest& request) const; /** * A Callable wrapper for DescribeMaintenanceWindowTargets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMaintenanceWindowTargetsOutcomeCallable DescribeMaintenanceWindowTargetsCallable(const DescribeMaintenanceWindowTargetsRequestT& request) const { return SubmitCallable(&SSMClient::DescribeMaintenanceWindowTargets, request); } /** * An Async wrapper for DescribeMaintenanceWindowTargets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMaintenanceWindowTargetsAsync(const DescribeMaintenanceWindowTargetsRequestT& request, const DescribeMaintenanceWindowTargetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeMaintenanceWindowTargets, request, handler, context); } /** *

Lists the tasks in a maintenance window.

For maintenance window * tasks without a specified target, you can't supply values for * --max-errors and --max-concurrency. Instead, the * system inserts a placeholder value of 1, which may be reported in * the response to this command. These values don't affect the running of your task * and can be ignored.

See Also:

AWS * API Reference

*/ virtual Model::DescribeMaintenanceWindowTasksOutcome DescribeMaintenanceWindowTasks(const Model::DescribeMaintenanceWindowTasksRequest& request) const; /** * A Callable wrapper for DescribeMaintenanceWindowTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMaintenanceWindowTasksOutcomeCallable DescribeMaintenanceWindowTasksCallable(const DescribeMaintenanceWindowTasksRequestT& request) const { return SubmitCallable(&SSMClient::DescribeMaintenanceWindowTasks, request); } /** * An Async wrapper for DescribeMaintenanceWindowTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMaintenanceWindowTasksAsync(const DescribeMaintenanceWindowTasksRequestT& request, const DescribeMaintenanceWindowTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeMaintenanceWindowTasks, request, handler, context); } /** *

Retrieves the maintenance windows in an Amazon Web Services * account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeMaintenanceWindowsOutcome DescribeMaintenanceWindows(const Model::DescribeMaintenanceWindowsRequest& request) const; /** * A Callable wrapper for DescribeMaintenanceWindows that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMaintenanceWindowsOutcomeCallable DescribeMaintenanceWindowsCallable(const DescribeMaintenanceWindowsRequestT& request) const { return SubmitCallable(&SSMClient::DescribeMaintenanceWindows, request); } /** * An Async wrapper for DescribeMaintenanceWindows that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMaintenanceWindowsAsync(const DescribeMaintenanceWindowsRequestT& request, const DescribeMaintenanceWindowsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeMaintenanceWindows, request, handler, context); } /** *

Retrieves information about the maintenance window targets or tasks that a * managed node is associated with.

See Also:

AWS * API Reference

*/ virtual Model::DescribeMaintenanceWindowsForTargetOutcome DescribeMaintenanceWindowsForTarget(const Model::DescribeMaintenanceWindowsForTargetRequest& request) const; /** * A Callable wrapper for DescribeMaintenanceWindowsForTarget that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMaintenanceWindowsForTargetOutcomeCallable DescribeMaintenanceWindowsForTargetCallable(const DescribeMaintenanceWindowsForTargetRequestT& request) const { return SubmitCallable(&SSMClient::DescribeMaintenanceWindowsForTarget, request); } /** * An Async wrapper for DescribeMaintenanceWindowsForTarget that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMaintenanceWindowsForTargetAsync(const DescribeMaintenanceWindowsForTargetRequestT& request, const DescribeMaintenanceWindowsForTargetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeMaintenanceWindowsForTarget, request, handler, context); } /** *

Query a set of OpsItems. You must have permission in Identity and Access * Management (IAM) to query a list of OpsItems. For more information, see Set * up OpsCenter in the Amazon Web Services Systems Manager User * Guide.

Operations engineers and IT professionals use Amazon Web * Services Systems Manager OpsCenter to view, investigate, and remediate * operational issues impacting the performance and health of their Amazon Web * Services resources. For more information, see OpsCenter * in the Amazon Web Services Systems Manager User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeOpsItemsOutcome DescribeOpsItems(const Model::DescribeOpsItemsRequest& request) const; /** * A Callable wrapper for DescribeOpsItems that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeOpsItemsOutcomeCallable DescribeOpsItemsCallable(const DescribeOpsItemsRequestT& request) const { return SubmitCallable(&SSMClient::DescribeOpsItems, request); } /** * An Async wrapper for DescribeOpsItems that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeOpsItemsAsync(const DescribeOpsItemsRequestT& request, const DescribeOpsItemsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeOpsItems, request, handler, context); } /** *

Get information about a parameter.

Request results are returned on a * best-effort basis. If you specify MaxResults in the request, the * response includes information up to the limit specified. The number of items * returned, however, can be between zero and the value of MaxResults. * If the service reaches an internal limit while processing the results, it stops * the operation and returns the matching values up to that point and a * NextToken. You can specify the NextToken in a * subsequent call to get the next set of results.

If you change * the KMS key alias for the KMS key used to encrypt a parameter, then you must * also update the key alias the parameter uses to reference KMS. Otherwise, * DescribeParameters retrieves whatever the original key alias was * referencing.

See Also:

AWS * API Reference

*/ virtual Model::DescribeParametersOutcome DescribeParameters(const Model::DescribeParametersRequest& request) const; /** * A Callable wrapper for DescribeParameters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeParametersOutcomeCallable DescribeParametersCallable(const DescribeParametersRequestT& request) const { return SubmitCallable(&SSMClient::DescribeParameters, request); } /** * An Async wrapper for DescribeParameters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeParametersAsync(const DescribeParametersRequestT& request, const DescribeParametersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeParameters, request, handler, context); } /** *

Lists the patch baselines in your Amazon Web Services account.

See * Also:

AWS * API Reference

*/ virtual Model::DescribePatchBaselinesOutcome DescribePatchBaselines(const Model::DescribePatchBaselinesRequest& request) const; /** * A Callable wrapper for DescribePatchBaselines that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePatchBaselinesOutcomeCallable DescribePatchBaselinesCallable(const DescribePatchBaselinesRequestT& request) const { return SubmitCallable(&SSMClient::DescribePatchBaselines, request); } /** * An Async wrapper for DescribePatchBaselines that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePatchBaselinesAsync(const DescribePatchBaselinesRequestT& request, const DescribePatchBaselinesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribePatchBaselines, request, handler, context); } /** *

Returns high-level aggregated patch compliance state information for a patch * group.

See Also:

AWS * API Reference

*/ virtual Model::DescribePatchGroupStateOutcome DescribePatchGroupState(const Model::DescribePatchGroupStateRequest& request) const; /** * A Callable wrapper for DescribePatchGroupState that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePatchGroupStateOutcomeCallable DescribePatchGroupStateCallable(const DescribePatchGroupStateRequestT& request) const { return SubmitCallable(&SSMClient::DescribePatchGroupState, request); } /** * An Async wrapper for DescribePatchGroupState that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePatchGroupStateAsync(const DescribePatchGroupStateRequestT& request, const DescribePatchGroupStateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribePatchGroupState, request, handler, context); } /** *

Lists all patch groups that have been registered with patch * baselines.

See Also:

AWS * API Reference

*/ virtual Model::DescribePatchGroupsOutcome DescribePatchGroups(const Model::DescribePatchGroupsRequest& request) const; /** * A Callable wrapper for DescribePatchGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePatchGroupsOutcomeCallable DescribePatchGroupsCallable(const DescribePatchGroupsRequestT& request) const { return SubmitCallable(&SSMClient::DescribePatchGroups, request); } /** * An Async wrapper for DescribePatchGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePatchGroupsAsync(const DescribePatchGroupsRequestT& request, const DescribePatchGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribePatchGroups, request, handler, context); } /** *

Lists the properties of available patches organized by product, product * family, classification, severity, and other properties of available patches. You * can use the reported properties in the filters you specify in requests for * operations such as CreatePatchBaseline, UpdatePatchBaseline, * DescribeAvailablePatches, and DescribePatchBaselines.

The * following section lists the properties that can be used in filters for each * major operating system type:

AMAZON_LINUX

Valid * properties: PRODUCT | CLASSIFICATION | * SEVERITY

AMAZON_LINUX_2

Valid * properties: PRODUCT | CLASSIFICATION | * SEVERITY

CENTOS

Valid properties: * PRODUCT | CLASSIFICATION | SEVERITY

*
DEBIAN

Valid properties: PRODUCT | * PRIORITY

MACOS

Valid properties: * PRODUCT | CLASSIFICATION

*
ORACLE_LINUX

Valid properties: PRODUCT | * CLASSIFICATION | SEVERITY

*
REDHAT_ENTERPRISE_LINUX

Valid properties: PRODUCT * | CLASSIFICATION | SEVERITY

SUSE
*

Valid properties: PRODUCT | CLASSIFICATION | * SEVERITY

UBUNTU

Valid properties: * PRODUCT | PRIORITY

WINDOWS
*

Valid properties: PRODUCT | PRODUCT_FAMILY | * CLASSIFICATION | MSRC_SEVERITY

*

See Also:

AWS * API Reference

*/ virtual Model::DescribePatchPropertiesOutcome DescribePatchProperties(const Model::DescribePatchPropertiesRequest& request) const; /** * A Callable wrapper for DescribePatchProperties that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePatchPropertiesOutcomeCallable DescribePatchPropertiesCallable(const DescribePatchPropertiesRequestT& request) const { return SubmitCallable(&SSMClient::DescribePatchProperties, request); } /** * An Async wrapper for DescribePatchProperties that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePatchPropertiesAsync(const DescribePatchPropertiesRequestT& request, const DescribePatchPropertiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribePatchProperties, request, handler, context); } /** *

Retrieves a list of all active sessions (both connected and disconnected) or * terminated sessions from the past 30 days.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSessionsOutcome DescribeSessions(const Model::DescribeSessionsRequest& request) const; /** * A Callable wrapper for DescribeSessions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSessionsOutcomeCallable DescribeSessionsCallable(const DescribeSessionsRequestT& request) const { return SubmitCallable(&SSMClient::DescribeSessions, request); } /** * An Async wrapper for DescribeSessions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSessionsAsync(const DescribeSessionsRequestT& request, const DescribeSessionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DescribeSessions, request, handler, context); } /** *

Deletes the association between an OpsItem and a related item. For example, * this API operation can delete an Incident Manager incident from an OpsItem. * Incident Manager is a capability of Amazon Web Services Systems * Manager.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateOpsItemRelatedItemOutcome DisassociateOpsItemRelatedItem(const Model::DisassociateOpsItemRelatedItemRequest& request) const; /** * A Callable wrapper for DisassociateOpsItemRelatedItem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateOpsItemRelatedItemOutcomeCallable DisassociateOpsItemRelatedItemCallable(const DisassociateOpsItemRelatedItemRequestT& request) const { return SubmitCallable(&SSMClient::DisassociateOpsItemRelatedItem, request); } /** * An Async wrapper for DisassociateOpsItemRelatedItem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateOpsItemRelatedItemAsync(const DisassociateOpsItemRelatedItemRequestT& request, const DisassociateOpsItemRelatedItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::DisassociateOpsItemRelatedItem, request, handler, context); } /** *

Get detailed information about a particular Automation * execution.

See Also:

AWS * API Reference

*/ virtual Model::GetAutomationExecutionOutcome GetAutomationExecution(const Model::GetAutomationExecutionRequest& request) const; /** * A Callable wrapper for GetAutomationExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAutomationExecutionOutcomeCallable GetAutomationExecutionCallable(const GetAutomationExecutionRequestT& request) const { return SubmitCallable(&SSMClient::GetAutomationExecution, request); } /** * An Async wrapper for GetAutomationExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAutomationExecutionAsync(const GetAutomationExecutionRequestT& request, const GetAutomationExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetAutomationExecution, request, handler, context); } /** *

Gets the state of a Amazon Web Services Systems Manager change calendar at * the current time or a specified time. If you specify a time, * GetCalendarState returns the state of the calendar at that specific * time, and returns the next time that the change calendar state will transition. * If you don't specify a time, GetCalendarState uses the current * time. Change Calendar entries have two possible states: OPEN or * CLOSED.

If you specify more than one calendar in a request, * the command returns the status of OPEN only if all calendars in the * request are open. If one or more calendars in the request are closed, the status * returned is CLOSED.

For more information about Change * Calendar, a capability of Amazon Web Services Systems Manager, see Amazon * Web Services Systems Manager Change Calendar in the Amazon Web Services * Systems Manager User Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetCalendarStateOutcome GetCalendarState(const Model::GetCalendarStateRequest& request) const; /** * A Callable wrapper for GetCalendarState that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCalendarStateOutcomeCallable GetCalendarStateCallable(const GetCalendarStateRequestT& request) const { return SubmitCallable(&SSMClient::GetCalendarState, request); } /** * An Async wrapper for GetCalendarState that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCalendarStateAsync(const GetCalendarStateRequestT& request, const GetCalendarStateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetCalendarState, request, handler, context); } /** *

Returns detailed information about command execution for an invocation or * plugin.

GetCommandInvocation only gives the execution * status of a plugin in a document. To get the command execution status on a * specific managed node, use ListCommandInvocations. To get the command * execution status across managed nodes, use ListCommands.

See * Also:

AWS * API Reference

*/ virtual Model::GetCommandInvocationOutcome GetCommandInvocation(const Model::GetCommandInvocationRequest& request) const; /** * A Callable wrapper for GetCommandInvocation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCommandInvocationOutcomeCallable GetCommandInvocationCallable(const GetCommandInvocationRequestT& request) const { return SubmitCallable(&SSMClient::GetCommandInvocation, request); } /** * An Async wrapper for GetCommandInvocation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCommandInvocationAsync(const GetCommandInvocationRequestT& request, const GetCommandInvocationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetCommandInvocation, request, handler, context); } /** *

Retrieves the Session Manager connection status for a managed node to * determine whether it is running and ready to receive Session Manager * connections.

See Also:

AWS * API Reference

*/ virtual Model::GetConnectionStatusOutcome GetConnectionStatus(const Model::GetConnectionStatusRequest& request) const; /** * A Callable wrapper for GetConnectionStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetConnectionStatusOutcomeCallable GetConnectionStatusCallable(const GetConnectionStatusRequestT& request) const { return SubmitCallable(&SSMClient::GetConnectionStatus, request); } /** * An Async wrapper for GetConnectionStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetConnectionStatusAsync(const GetConnectionStatusRequestT& request, const GetConnectionStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetConnectionStatus, request, handler, context); } /** *

Retrieves the default patch baseline. Amazon Web Services Systems Manager * supports creating multiple default patch baselines. For example, you can create * a default patch baseline for each operating system.

If you don't specify * an operating system value, the default patch baseline for Windows is * returned.

See Also:

AWS * API Reference

*/ virtual Model::GetDefaultPatchBaselineOutcome GetDefaultPatchBaseline(const Model::GetDefaultPatchBaselineRequest& request) const; /** * A Callable wrapper for GetDefaultPatchBaseline that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDefaultPatchBaselineOutcomeCallable GetDefaultPatchBaselineCallable(const GetDefaultPatchBaselineRequestT& request) const { return SubmitCallable(&SSMClient::GetDefaultPatchBaseline, request); } /** * An Async wrapper for GetDefaultPatchBaseline that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDefaultPatchBaselineAsync(const GetDefaultPatchBaselineRequestT& request, const GetDefaultPatchBaselineResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetDefaultPatchBaseline, request, handler, context); } /** *

Retrieves the current snapshot for the patch baseline the managed node uses. * This API is primarily used by the AWS-RunPatchBaseline Systems * Manager document (SSM document).

If you run the command locally, * such as with the Command Line Interface (CLI), the system attempts to use your * local Amazon Web Services credentials and the operation fails. To avoid this, * you can run the command in the Amazon Web Services Systems Manager console. Use * Run Command, a capability of Amazon Web Services Systems Manager, with an SSM * document that enables you to target a managed node with a script or command. For * example, run the command using the AWS-RunShellScript document or * the AWS-RunPowerShellScript document.

See * Also:

AWS * API Reference

*/ virtual Model::GetDeployablePatchSnapshotForInstanceOutcome GetDeployablePatchSnapshotForInstance(const Model::GetDeployablePatchSnapshotForInstanceRequest& request) const; /** * A Callable wrapper for GetDeployablePatchSnapshotForInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDeployablePatchSnapshotForInstanceOutcomeCallable GetDeployablePatchSnapshotForInstanceCallable(const GetDeployablePatchSnapshotForInstanceRequestT& request) const { return SubmitCallable(&SSMClient::GetDeployablePatchSnapshotForInstance, request); } /** * An Async wrapper for GetDeployablePatchSnapshotForInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDeployablePatchSnapshotForInstanceAsync(const GetDeployablePatchSnapshotForInstanceRequestT& request, const GetDeployablePatchSnapshotForInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetDeployablePatchSnapshotForInstance, request, handler, context); } /** *

Gets the contents of the specified Amazon Web Services Systems Manager * document (SSM document).

See Also:

AWS API * Reference

*/ virtual Model::GetDocumentOutcome GetDocument(const Model::GetDocumentRequest& request) const; /** * A Callable wrapper for GetDocument that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDocumentOutcomeCallable GetDocumentCallable(const GetDocumentRequestT& request) const { return SubmitCallable(&SSMClient::GetDocument, request); } /** * An Async wrapper for GetDocument that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDocumentAsync(const GetDocumentRequestT& request, const GetDocumentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetDocument, request, handler, context); } /** *

Query inventory information. This includes managed node status, such as * Stopped or Terminated.

See Also:

AWS * API Reference

*/ virtual Model::GetInventoryOutcome GetInventory(const Model::GetInventoryRequest& request) const; /** * A Callable wrapper for GetInventory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInventoryOutcomeCallable GetInventoryCallable(const GetInventoryRequestT& request) const { return SubmitCallable(&SSMClient::GetInventory, request); } /** * An Async wrapper for GetInventory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInventoryAsync(const GetInventoryRequestT& request, const GetInventoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetInventory, request, handler, context); } /** *

Return a list of inventory type names for the account, or return a list of * attribute names for a specific Inventory item type.

See Also:

* AWS * API Reference

*/ virtual Model::GetInventorySchemaOutcome GetInventorySchema(const Model::GetInventorySchemaRequest& request) const; /** * A Callable wrapper for GetInventorySchema that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInventorySchemaOutcomeCallable GetInventorySchemaCallable(const GetInventorySchemaRequestT& request) const { return SubmitCallable(&SSMClient::GetInventorySchema, request); } /** * An Async wrapper for GetInventorySchema that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInventorySchemaAsync(const GetInventorySchemaRequestT& request, const GetInventorySchemaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetInventorySchema, request, handler, context); } /** *

Retrieves a maintenance window.

See Also:

AWS * API Reference

*/ virtual Model::GetMaintenanceWindowOutcome GetMaintenanceWindow(const Model::GetMaintenanceWindowRequest& request) const; /** * A Callable wrapper for GetMaintenanceWindow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMaintenanceWindowOutcomeCallable GetMaintenanceWindowCallable(const GetMaintenanceWindowRequestT& request) const { return SubmitCallable(&SSMClient::GetMaintenanceWindow, request); } /** * An Async wrapper for GetMaintenanceWindow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMaintenanceWindowAsync(const GetMaintenanceWindowRequestT& request, const GetMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetMaintenanceWindow, request, handler, context); } /** *

Retrieves details about a specific a maintenance window * execution.

See Also:

AWS * API Reference

*/ virtual Model::GetMaintenanceWindowExecutionOutcome GetMaintenanceWindowExecution(const Model::GetMaintenanceWindowExecutionRequest& request) const; /** * A Callable wrapper for GetMaintenanceWindowExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMaintenanceWindowExecutionOutcomeCallable GetMaintenanceWindowExecutionCallable(const GetMaintenanceWindowExecutionRequestT& request) const { return SubmitCallable(&SSMClient::GetMaintenanceWindowExecution, request); } /** * An Async wrapper for GetMaintenanceWindowExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMaintenanceWindowExecutionAsync(const GetMaintenanceWindowExecutionRequestT& request, const GetMaintenanceWindowExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetMaintenanceWindowExecution, request, handler, context); } /** *

Retrieves the details about a specific task run as part of a maintenance * window execution.

See Also:

AWS * API Reference

*/ virtual Model::GetMaintenanceWindowExecutionTaskOutcome GetMaintenanceWindowExecutionTask(const Model::GetMaintenanceWindowExecutionTaskRequest& request) const; /** * A Callable wrapper for GetMaintenanceWindowExecutionTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMaintenanceWindowExecutionTaskOutcomeCallable GetMaintenanceWindowExecutionTaskCallable(const GetMaintenanceWindowExecutionTaskRequestT& request) const { return SubmitCallable(&SSMClient::GetMaintenanceWindowExecutionTask, request); } /** * An Async wrapper for GetMaintenanceWindowExecutionTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMaintenanceWindowExecutionTaskAsync(const GetMaintenanceWindowExecutionTaskRequestT& request, const GetMaintenanceWindowExecutionTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetMaintenanceWindowExecutionTask, request, handler, context); } /** *

Retrieves information about a specific task running on a specific * target.

See Also:

AWS * API Reference

*/ virtual Model::GetMaintenanceWindowExecutionTaskInvocationOutcome GetMaintenanceWindowExecutionTaskInvocation(const Model::GetMaintenanceWindowExecutionTaskInvocationRequest& request) const; /** * A Callable wrapper for GetMaintenanceWindowExecutionTaskInvocation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMaintenanceWindowExecutionTaskInvocationOutcomeCallable GetMaintenanceWindowExecutionTaskInvocationCallable(const GetMaintenanceWindowExecutionTaskInvocationRequestT& request) const { return SubmitCallable(&SSMClient::GetMaintenanceWindowExecutionTaskInvocation, request); } /** * An Async wrapper for GetMaintenanceWindowExecutionTaskInvocation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMaintenanceWindowExecutionTaskInvocationAsync(const GetMaintenanceWindowExecutionTaskInvocationRequestT& request, const GetMaintenanceWindowExecutionTaskInvocationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetMaintenanceWindowExecutionTaskInvocation, request, handler, context); } /** *

Retrieves the details of a maintenance window task.

For * maintenance window tasks without a specified target, you can't supply values for * --max-errors and --max-concurrency. Instead, the * system inserts a placeholder value of 1, which may be reported in * the response to this command. These values don't affect the running of your task * and can be ignored.

To retrieve a list of tasks in a maintenance * window, instead use the DescribeMaintenanceWindowTasks * command.

See Also:

AWS * API Reference

*/ virtual Model::GetMaintenanceWindowTaskOutcome GetMaintenanceWindowTask(const Model::GetMaintenanceWindowTaskRequest& request) const; /** * A Callable wrapper for GetMaintenanceWindowTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMaintenanceWindowTaskOutcomeCallable GetMaintenanceWindowTaskCallable(const GetMaintenanceWindowTaskRequestT& request) const { return SubmitCallable(&SSMClient::GetMaintenanceWindowTask, request); } /** * An Async wrapper for GetMaintenanceWindowTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMaintenanceWindowTaskAsync(const GetMaintenanceWindowTaskRequestT& request, const GetMaintenanceWindowTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetMaintenanceWindowTask, request, handler, context); } /** *

Get information about an OpsItem by using the ID. You must have permission in * Identity and Access Management (IAM) to view information about an OpsItem. For * more information, see Set * up OpsCenter in the Amazon Web Services Systems Manager User * Guide.

Operations engineers and IT professionals use Amazon Web * Services Systems Manager OpsCenter to view, investigate, and remediate * operational issues impacting the performance and health of their Amazon Web * Services resources. For more information, see OpsCenter * in the Amazon Web Services Systems Manager User Guide.

See * Also:

AWS API * Reference

*/ virtual Model::GetOpsItemOutcome GetOpsItem(const Model::GetOpsItemRequest& request) const; /** * A Callable wrapper for GetOpsItem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOpsItemOutcomeCallable GetOpsItemCallable(const GetOpsItemRequestT& request) const { return SubmitCallable(&SSMClient::GetOpsItem, request); } /** * An Async wrapper for GetOpsItem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOpsItemAsync(const GetOpsItemRequestT& request, const GetOpsItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetOpsItem, request, handler, context); } /** *

View operational metadata related to an application in Application * Manager.

See Also:

AWS * API Reference

*/ virtual Model::GetOpsMetadataOutcome GetOpsMetadata(const Model::GetOpsMetadataRequest& request) const; /** * A Callable wrapper for GetOpsMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOpsMetadataOutcomeCallable GetOpsMetadataCallable(const GetOpsMetadataRequestT& request) const { return SubmitCallable(&SSMClient::GetOpsMetadata, request); } /** * An Async wrapper for GetOpsMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOpsMetadataAsync(const GetOpsMetadataRequestT& request, const GetOpsMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetOpsMetadata, request, handler, context); } /** *

View a summary of operations metadata (OpsData) based on specified filters * and aggregators. OpsData can include information about Amazon Web Services * Systems Manager OpsCenter operational workitems (OpsItems) as well as * information about any Amazon Web Services resource or service configured to * report OpsData to Amazon Web Services Systems Manager Explorer.

See * Also:

AWS * API Reference

*/ virtual Model::GetOpsSummaryOutcome GetOpsSummary(const Model::GetOpsSummaryRequest& request) const; /** * A Callable wrapper for GetOpsSummary that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOpsSummaryOutcomeCallable GetOpsSummaryCallable(const GetOpsSummaryRequestT& request) const { return SubmitCallable(&SSMClient::GetOpsSummary, request); } /** * An Async wrapper for GetOpsSummary that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOpsSummaryAsync(const GetOpsSummaryRequestT& request, const GetOpsSummaryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetOpsSummary, request, handler, context); } /** *

Get information about a single parameter by specifying the parameter * name.

To get information about more than one parameter at a time, * use the GetParameters operation.

See Also:

AWS * API Reference

*/ virtual Model::GetParameterOutcome GetParameter(const Model::GetParameterRequest& request) const; /** * A Callable wrapper for GetParameter that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetParameterOutcomeCallable GetParameterCallable(const GetParameterRequestT& request) const { return SubmitCallable(&SSMClient::GetParameter, request); } /** * An Async wrapper for GetParameter that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetParameterAsync(const GetParameterRequestT& request, const GetParameterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetParameter, request, handler, context); } /** *

Retrieves the history of all changes to a parameter.

If * you change the KMS key alias for the KMS key used to encrypt a parameter, then * you must also update the key alias the parameter uses to reference KMS. * Otherwise, GetParameterHistory retrieves whatever the original key * alias was referencing.

See Also:

AWS * API Reference

*/ virtual Model::GetParameterHistoryOutcome GetParameterHistory(const Model::GetParameterHistoryRequest& request) const; /** * A Callable wrapper for GetParameterHistory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetParameterHistoryOutcomeCallable GetParameterHistoryCallable(const GetParameterHistoryRequestT& request) const { return SubmitCallable(&SSMClient::GetParameterHistory, request); } /** * An Async wrapper for GetParameterHistory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetParameterHistoryAsync(const GetParameterHistoryRequestT& request, const GetParameterHistoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetParameterHistory, request, handler, context); } /** *

Get information about one or more parameters by specifying multiple parameter * names.

To get information about a single parameter, you can use * the GetParameter operation instead.

See Also:

AWS * API Reference

*/ virtual Model::GetParametersOutcome GetParameters(const Model::GetParametersRequest& request) const; /** * A Callable wrapper for GetParameters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetParametersOutcomeCallable GetParametersCallable(const GetParametersRequestT& request) const { return SubmitCallable(&SSMClient::GetParameters, request); } /** * An Async wrapper for GetParameters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetParametersAsync(const GetParametersRequestT& request, const GetParametersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetParameters, request, handler, context); } /** *

Retrieve information about one or more parameters in a specific hierarchy. *

Request results are returned on a best-effort basis. If you specify * MaxResults in the request, the response includes information up to * the limit specified. The number of items returned, however, can be between zero * and the value of MaxResults. If the service reaches an internal * limit while processing the results, it stops the operation and returns the * matching values up to that point and a NextToken. You can specify * the NextToken in a subsequent call to get the next set of * results.

See Also:

AWS * API Reference

*/ virtual Model::GetParametersByPathOutcome GetParametersByPath(const Model::GetParametersByPathRequest& request) const; /** * A Callable wrapper for GetParametersByPath that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetParametersByPathOutcomeCallable GetParametersByPathCallable(const GetParametersByPathRequestT& request) const { return SubmitCallable(&SSMClient::GetParametersByPath, request); } /** * An Async wrapper for GetParametersByPath that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetParametersByPathAsync(const GetParametersByPathRequestT& request, const GetParametersByPathResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetParametersByPath, request, handler, context); } /** *

Retrieves information about a patch baseline.

See Also:

AWS * API Reference

*/ virtual Model::GetPatchBaselineOutcome GetPatchBaseline(const Model::GetPatchBaselineRequest& request) const; /** * A Callable wrapper for GetPatchBaseline that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPatchBaselineOutcomeCallable GetPatchBaselineCallable(const GetPatchBaselineRequestT& request) const { return SubmitCallable(&SSMClient::GetPatchBaseline, request); } /** * An Async wrapper for GetPatchBaseline that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPatchBaselineAsync(const GetPatchBaselineRequestT& request, const GetPatchBaselineResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetPatchBaseline, request, handler, context); } /** *

Retrieves the patch baseline that should be used for the specified patch * group.

See Also:

AWS * API Reference

*/ virtual Model::GetPatchBaselineForPatchGroupOutcome GetPatchBaselineForPatchGroup(const Model::GetPatchBaselineForPatchGroupRequest& request) const; /** * A Callable wrapper for GetPatchBaselineForPatchGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPatchBaselineForPatchGroupOutcomeCallable GetPatchBaselineForPatchGroupCallable(const GetPatchBaselineForPatchGroupRequestT& request) const { return SubmitCallable(&SSMClient::GetPatchBaselineForPatchGroup, request); } /** * An Async wrapper for GetPatchBaselineForPatchGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPatchBaselineForPatchGroupAsync(const GetPatchBaselineForPatchGroupRequestT& request, const GetPatchBaselineForPatchGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetPatchBaselineForPatchGroup, request, handler, context); } /** *

Returns an array of the Policy object.

See Also:

* AWS * API Reference

*/ virtual Model::GetResourcePoliciesOutcome GetResourcePolicies(const Model::GetResourcePoliciesRequest& request) const; /** * A Callable wrapper for GetResourcePolicies that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetResourcePoliciesOutcomeCallable GetResourcePoliciesCallable(const GetResourcePoliciesRequestT& request) const { return SubmitCallable(&SSMClient::GetResourcePolicies, request); } /** * An Async wrapper for GetResourcePolicies that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetResourcePoliciesAsync(const GetResourcePoliciesRequestT& request, const GetResourcePoliciesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetResourcePolicies, request, handler, context); } /** *

ServiceSetting is an account-level setting for an Amazon Web * Services service. This setting defines how a user interacts with or uses a * service or a feature of a service. For example, if an Amazon Web Services * service charges money to the account based on feature or service usage, then the * Amazon Web Services service team might create a default setting of * false. This means the user can't use this feature unless they * change the setting to true and intentionally opt in for a paid * feature.

Services map a SettingId object to a setting value. * Amazon Web Services services teams define the default value for a * SettingId. You can't create a new SettingId, but you * can overwrite the default value if you have the * ssm:UpdateServiceSetting permission for the setting. Use the * UpdateServiceSetting API operation to change the default setting. Or use * the ResetServiceSetting to change the value back to the original value * defined by the Amazon Web Services service team.

Query the current * service setting for the Amazon Web Services account.

See Also:

* AWS * API Reference

*/ virtual Model::GetServiceSettingOutcome GetServiceSetting(const Model::GetServiceSettingRequest& request) const; /** * A Callable wrapper for GetServiceSetting that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetServiceSettingOutcomeCallable GetServiceSettingCallable(const GetServiceSettingRequestT& request) const { return SubmitCallable(&SSMClient::GetServiceSetting, request); } /** * An Async wrapper for GetServiceSetting that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetServiceSettingAsync(const GetServiceSettingRequestT& request, const GetServiceSettingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::GetServiceSetting, request, handler, context); } /** *

A parameter label is a user-defined alias to help you manage different * versions of a parameter. When you modify a parameter, Amazon Web Services * Systems Manager automatically saves a new version and increments the version * number by one. A label can help you remember the purpose of a parameter when * there are multiple versions.

Parameter labels have the following * requirements and restrictions.

  • A version of a parameter can * have a maximum of 10 labels.

  • You can't attach the same label * to different versions of the same parameter. For example, if version 1 has the * label Production, then you can't attach Production to version 2.

  • *

    You can move a label from one version of a parameter to another.

    • *

  • You can't create a label when you create a new parameter. You must * attach a label to a specific version of a parameter.

  • If you no * longer want to use a parameter label, then you can either delete it or move it * to a different version of a parameter.

  • A label can have a * maximum of 100 characters.

  • Labels can contain letters (case * sensitive), numbers, periods (.), hyphens (-), or underscores (_).

    • *

  • Labels can't begin with a number, "aws" or * "ssm" (not case sensitive). If a label fails to meet these * requirements, then the label isn't associated with a parameter and the system * displays it in the list of InvalidLabels.

See Also:

* AWS * API Reference

*/ virtual Model::LabelParameterVersionOutcome LabelParameterVersion(const Model::LabelParameterVersionRequest& request) const; /** * A Callable wrapper for LabelParameterVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::LabelParameterVersionOutcomeCallable LabelParameterVersionCallable(const LabelParameterVersionRequestT& request) const { return SubmitCallable(&SSMClient::LabelParameterVersion, request); } /** * An Async wrapper for LabelParameterVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void LabelParameterVersionAsync(const LabelParameterVersionRequestT& request, const LabelParameterVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::LabelParameterVersion, request, handler, context); } /** *

Retrieves all versions of an association for a specific association * ID.

See Also:

AWS * API Reference

*/ virtual Model::ListAssociationVersionsOutcome ListAssociationVersions(const Model::ListAssociationVersionsRequest& request) const; /** * A Callable wrapper for ListAssociationVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssociationVersionsOutcomeCallable ListAssociationVersionsCallable(const ListAssociationVersionsRequestT& request) const { return SubmitCallable(&SSMClient::ListAssociationVersions, request); } /** * An Async wrapper for ListAssociationVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssociationVersionsAsync(const ListAssociationVersionsRequestT& request, const ListAssociationVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListAssociationVersions, request, handler, context); } /** *

Returns all State Manager associations in the current Amazon Web Services * account and Amazon Web Services Region. You can limit the results to a specific * State Manager association document or managed node by specifying a filter. State * Manager is a capability of Amazon Web Services Systems Manager.

See * Also:

AWS * API Reference

*/ virtual Model::ListAssociationsOutcome ListAssociations(const Model::ListAssociationsRequest& request) const; /** * A Callable wrapper for ListAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssociationsOutcomeCallable ListAssociationsCallable(const ListAssociationsRequestT& request) const { return SubmitCallable(&SSMClient::ListAssociations, request); } /** * An Async wrapper for ListAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssociationsAsync(const ListAssociationsRequestT& request, const ListAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListAssociations, request, handler, context); } /** *

An invocation is copy of a command sent to a specific managed node. A command * can apply to one or more managed nodes. A command invocation applies to one * managed node. For example, if a user runs SendCommand against three * managed nodes, then a command invocation is created for each requested managed * node ID. ListCommandInvocations provide status about command * execution.

See Also:

AWS * API Reference

*/ virtual Model::ListCommandInvocationsOutcome ListCommandInvocations(const Model::ListCommandInvocationsRequest& request) const; /** * A Callable wrapper for ListCommandInvocations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCommandInvocationsOutcomeCallable ListCommandInvocationsCallable(const ListCommandInvocationsRequestT& request) const { return SubmitCallable(&SSMClient::ListCommandInvocations, request); } /** * An Async wrapper for ListCommandInvocations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCommandInvocationsAsync(const ListCommandInvocationsRequestT& request, const ListCommandInvocationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListCommandInvocations, request, handler, context); } /** *

Lists the commands requested by users of the Amazon Web Services * account.

See Also:

AWS * API Reference

*/ virtual Model::ListCommandsOutcome ListCommands(const Model::ListCommandsRequest& request) const; /** * A Callable wrapper for ListCommands that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCommandsOutcomeCallable ListCommandsCallable(const ListCommandsRequestT& request) const { return SubmitCallable(&SSMClient::ListCommands, request); } /** * An Async wrapper for ListCommands that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCommandsAsync(const ListCommandsRequestT& request, const ListCommandsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListCommands, request, handler, context); } /** *

For a specified resource ID, this API operation returns a list of compliance * statuses for different resource types. Currently, you can only specify one * resource ID per call. List results depend on the criteria specified in the * filter.

See Also:

AWS * API Reference

*/ virtual Model::ListComplianceItemsOutcome ListComplianceItems(const Model::ListComplianceItemsRequest& request) const; /** * A Callable wrapper for ListComplianceItems that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListComplianceItemsOutcomeCallable ListComplianceItemsCallable(const ListComplianceItemsRequestT& request) const { return SubmitCallable(&SSMClient::ListComplianceItems, request); } /** * An Async wrapper for ListComplianceItems that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListComplianceItemsAsync(const ListComplianceItemsRequestT& request, const ListComplianceItemsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListComplianceItems, request, handler, context); } /** *

Returns a summary count of compliant and non-compliant resources for a * compliance type. For example, this call can return State Manager associations, * patches, or custom compliance types according to the filter criteria that you * specify.

See Also:

AWS * API Reference

*/ virtual Model::ListComplianceSummariesOutcome ListComplianceSummaries(const Model::ListComplianceSummariesRequest& request) const; /** * A Callable wrapper for ListComplianceSummaries that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListComplianceSummariesOutcomeCallable ListComplianceSummariesCallable(const ListComplianceSummariesRequestT& request) const { return SubmitCallable(&SSMClient::ListComplianceSummaries, request); } /** * An Async wrapper for ListComplianceSummaries that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListComplianceSummariesAsync(const ListComplianceSummariesRequestT& request, const ListComplianceSummariesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListComplianceSummaries, request, handler, context); } /** *

Information about approval reviews for a version of a change template in * Change Manager.

See Also:

AWS * API Reference

*/ virtual Model::ListDocumentMetadataHistoryOutcome ListDocumentMetadataHistory(const Model::ListDocumentMetadataHistoryRequest& request) const; /** * A Callable wrapper for ListDocumentMetadataHistory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDocumentMetadataHistoryOutcomeCallable ListDocumentMetadataHistoryCallable(const ListDocumentMetadataHistoryRequestT& request) const { return SubmitCallable(&SSMClient::ListDocumentMetadataHistory, request); } /** * An Async wrapper for ListDocumentMetadataHistory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDocumentMetadataHistoryAsync(const ListDocumentMetadataHistoryRequestT& request, const ListDocumentMetadataHistoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListDocumentMetadataHistory, request, handler, context); } /** *

List all versions for a document.

See Also:

AWS * API Reference

*/ virtual Model::ListDocumentVersionsOutcome ListDocumentVersions(const Model::ListDocumentVersionsRequest& request) const; /** * A Callable wrapper for ListDocumentVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDocumentVersionsOutcomeCallable ListDocumentVersionsCallable(const ListDocumentVersionsRequestT& request) const { return SubmitCallable(&SSMClient::ListDocumentVersions, request); } /** * An Async wrapper for ListDocumentVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDocumentVersionsAsync(const ListDocumentVersionsRequestT& request, const ListDocumentVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListDocumentVersions, request, handler, context); } /** *

Returns all Systems Manager (SSM) documents in the current Amazon Web * Services account and Amazon Web Services Region. You can limit the results of * this request by using a filter.

See Also:

AWS * API Reference

*/ virtual Model::ListDocumentsOutcome ListDocuments(const Model::ListDocumentsRequest& request) const; /** * A Callable wrapper for ListDocuments that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDocumentsOutcomeCallable ListDocumentsCallable(const ListDocumentsRequestT& request) const { return SubmitCallable(&SSMClient::ListDocuments, request); } /** * An Async wrapper for ListDocuments that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDocumentsAsync(const ListDocumentsRequestT& request, const ListDocumentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListDocuments, request, handler, context); } /** *

A list of inventory items returned by the request.

See Also:

* AWS * API Reference

*/ virtual Model::ListInventoryEntriesOutcome ListInventoryEntries(const Model::ListInventoryEntriesRequest& request) const; /** * A Callable wrapper for ListInventoryEntries that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListInventoryEntriesOutcomeCallable ListInventoryEntriesCallable(const ListInventoryEntriesRequestT& request) const { return SubmitCallable(&SSMClient::ListInventoryEntries, request); } /** * An Async wrapper for ListInventoryEntries that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListInventoryEntriesAsync(const ListInventoryEntriesRequestT& request, const ListInventoryEntriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListInventoryEntries, request, handler, context); } /** *

Returns a list of all OpsItem events in the current Amazon Web Services * Region and Amazon Web Services account. You can limit the results to events * associated with specific OpsItems by specifying a filter.

See * Also:

AWS * API Reference

*/ virtual Model::ListOpsItemEventsOutcome ListOpsItemEvents(const Model::ListOpsItemEventsRequest& request) const; /** * A Callable wrapper for ListOpsItemEvents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListOpsItemEventsOutcomeCallable ListOpsItemEventsCallable(const ListOpsItemEventsRequestT& request) const { return SubmitCallable(&SSMClient::ListOpsItemEvents, request); } /** * An Async wrapper for ListOpsItemEvents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListOpsItemEventsAsync(const ListOpsItemEventsRequestT& request, const ListOpsItemEventsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListOpsItemEvents, request, handler, context); } /** *

Lists all related-item resources associated with a Systems Manager OpsCenter * OpsItem. OpsCenter is a capability of Amazon Web Services Systems * Manager.

See Also:

AWS * API Reference

*/ virtual Model::ListOpsItemRelatedItemsOutcome ListOpsItemRelatedItems(const Model::ListOpsItemRelatedItemsRequest& request) const; /** * A Callable wrapper for ListOpsItemRelatedItems that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListOpsItemRelatedItemsOutcomeCallable ListOpsItemRelatedItemsCallable(const ListOpsItemRelatedItemsRequestT& request) const { return SubmitCallable(&SSMClient::ListOpsItemRelatedItems, request); } /** * An Async wrapper for ListOpsItemRelatedItems that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListOpsItemRelatedItemsAsync(const ListOpsItemRelatedItemsRequestT& request, const ListOpsItemRelatedItemsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListOpsItemRelatedItems, request, handler, context); } /** *

Amazon Web Services Systems Manager calls this API operation when displaying * all Application Manager OpsMetadata objects or blobs.

See Also:

* AWS * API Reference

*/ virtual Model::ListOpsMetadataOutcome ListOpsMetadata(const Model::ListOpsMetadataRequest& request) const; /** * A Callable wrapper for ListOpsMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListOpsMetadataOutcomeCallable ListOpsMetadataCallable(const ListOpsMetadataRequestT& request) const { return SubmitCallable(&SSMClient::ListOpsMetadata, request); } /** * An Async wrapper for ListOpsMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListOpsMetadataAsync(const ListOpsMetadataRequestT& request, const ListOpsMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListOpsMetadata, request, handler, context); } /** *

Returns a resource-level summary count. The summary includes information * about compliant and non-compliant statuses and detailed compliance-item severity * counts, according to the filter criteria you specify.

See Also:

* AWS * API Reference

*/ virtual Model::ListResourceComplianceSummariesOutcome ListResourceComplianceSummaries(const Model::ListResourceComplianceSummariesRequest& request) const; /** * A Callable wrapper for ListResourceComplianceSummaries that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResourceComplianceSummariesOutcomeCallable ListResourceComplianceSummariesCallable(const ListResourceComplianceSummariesRequestT& request) const { return SubmitCallable(&SSMClient::ListResourceComplianceSummaries, request); } /** * An Async wrapper for ListResourceComplianceSummaries that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResourceComplianceSummariesAsync(const ListResourceComplianceSummariesRequestT& request, const ListResourceComplianceSummariesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListResourceComplianceSummaries, request, handler, context); } /** *

Lists your resource data sync configurations. Includes information about the * last time a sync attempted to start, the last sync status, and the last time a * sync successfully completed.

The number of sync configurations might be * too large to return using a single call to ListResourceDataSync. * You can limit the number of sync configurations returned by using the * MaxResults parameter. To determine whether there are more sync * configurations to list, check the value of NextToken in the output. * If there are more sync configurations to list, you can request them by * specifying the NextToken returned in the call to the parameter of a * subsequent call.

See Also:

AWS * API Reference

*/ virtual Model::ListResourceDataSyncOutcome ListResourceDataSync(const Model::ListResourceDataSyncRequest& request) const; /** * A Callable wrapper for ListResourceDataSync that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResourceDataSyncOutcomeCallable ListResourceDataSyncCallable(const ListResourceDataSyncRequestT& request) const { return SubmitCallable(&SSMClient::ListResourceDataSync, request); } /** * An Async wrapper for ListResourceDataSync that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResourceDataSyncAsync(const ListResourceDataSyncRequestT& request, const ListResourceDataSyncResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListResourceDataSync, request, handler, context); } /** *

Returns a list of the tags assigned to the specified resource.

For * information about the ID format for each supported resource type, see * AddTagsToResource.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&SSMClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ListTagsForResource, request, handler, context); } /** *

Shares a Amazon Web Services Systems Manager document (SSM document)publicly * or privately. If you share a document privately, you must specify the Amazon Web * Services user IDs for those people who can use the document. If you share a * document publicly, you must specify All as the account ID.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyDocumentPermissionOutcome ModifyDocumentPermission(const Model::ModifyDocumentPermissionRequest& request) const; /** * A Callable wrapper for ModifyDocumentPermission that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyDocumentPermissionOutcomeCallable ModifyDocumentPermissionCallable(const ModifyDocumentPermissionRequestT& request) const { return SubmitCallable(&SSMClient::ModifyDocumentPermission, request); } /** * An Async wrapper for ModifyDocumentPermission that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyDocumentPermissionAsync(const ModifyDocumentPermissionRequestT& request, const ModifyDocumentPermissionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ModifyDocumentPermission, request, handler, context); } /** *

Registers a compliance type and other compliance details on a designated * resource. This operation lets you register custom compliance details with a * resource. This call overwrites existing compliance information on the resource, * so you must provide a full list of compliance items each time that you send the * request.

ComplianceType can be one of the following:

  • *

    ExecutionId: The execution ID when the patch, association, or custom * compliance item was applied.

  • ExecutionType: Specify patch, * association, or Custom:string.

  • ExecutionTime. The * time the patch, association, or custom compliance item was applied to the * managed node.

  • Id: The patch, association, or custom compliance * ID.

  • Title: A title.

  • Status: The status of * the compliance item. For example, approved for patches, or * Failed for associations.

  • Severity: A patch * severity. For example, Critical.

  • DocumentName: An * SSM document name. For example, AWS-RunPatchBaseline.

    • *

  • DocumentVersion: An SSM document version number. For example, 4.

    *

  • Classification: A patch classification. For example, * security updates.

  • PatchBaselineId: A patch * baseline ID.

  • PatchSeverity: A patch severity. For example, * Critical.

  • PatchState: A patch state. For example, * InstancesWithFailedPatches.

  • PatchGroup: The name * of a patch group.

  • InstalledTime: The time the association, * patch, or custom compliance item was applied to the resource. Specify the time * by using the following format: yyyy-MM-dd'T'HH:mm:ss'Z'

    • *

See Also:

AWS * API Reference

*/ virtual Model::PutComplianceItemsOutcome PutComplianceItems(const Model::PutComplianceItemsRequest& request) const; /** * A Callable wrapper for PutComplianceItems that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutComplianceItemsOutcomeCallable PutComplianceItemsCallable(const PutComplianceItemsRequestT& request) const { return SubmitCallable(&SSMClient::PutComplianceItems, request); } /** * An Async wrapper for PutComplianceItems that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutComplianceItemsAsync(const PutComplianceItemsRequestT& request, const PutComplianceItemsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::PutComplianceItems, request, handler, context); } /** *

Bulk update custom inventory items on one or more managed nodes. The request * adds an inventory item, if it doesn't already exist, or updates an inventory * item, if it does exist.

See Also:

AWS * API Reference

*/ virtual Model::PutInventoryOutcome PutInventory(const Model::PutInventoryRequest& request) const; /** * A Callable wrapper for PutInventory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutInventoryOutcomeCallable PutInventoryCallable(const PutInventoryRequestT& request) const { return SubmitCallable(&SSMClient::PutInventory, request); } /** * An Async wrapper for PutInventory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutInventoryAsync(const PutInventoryRequestT& request, const PutInventoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::PutInventory, request, handler, context); } /** *

Add a parameter to the system.

See Also:

AWS * API Reference

*/ virtual Model::PutParameterOutcome PutParameter(const Model::PutParameterRequest& request) const; /** * A Callable wrapper for PutParameter that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutParameterOutcomeCallable PutParameterCallable(const PutParameterRequestT& request) const { return SubmitCallable(&SSMClient::PutParameter, request); } /** * An Async wrapper for PutParameter that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutParameterAsync(const PutParameterRequestT& request, const PutParameterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::PutParameter, request, handler, context); } /** *

Creates or updates a Systems Manager resource policy. A resource policy helps * you to define the IAM entity (for example, an Amazon Web Services account) that * can manage your Systems Manager resources. Currently, OpsItemGroup * is the only resource that supports Systems Manager resource policies. The * resource policy for OpsItemGroup enables Amazon Web Services * accounts to view and interact with OpsCenter operational work items * (OpsItems).

See Also:

AWS * API Reference

*/ virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const; /** * A Callable wrapper for PutResourcePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const { return SubmitCallable(&SSMClient::PutResourcePolicy, request); } /** * An Async wrapper for PutResourcePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::PutResourcePolicy, request, handler, context); } /** *

Defines the default patch baseline for the relevant operating system.

*

To reset the Amazon Web Services-predefined patch baseline as the default, * specify the full patch baseline Amazon Resource Name (ARN) as the baseline ID * value. For example, for CentOS, specify * arn:aws:ssm:us-east-2:733109147000:patchbaseline/pb-0574b43a65ea646ed * instead of pb-0574b43a65ea646ed.

See Also:

AWS * API Reference

*/ virtual Model::RegisterDefaultPatchBaselineOutcome RegisterDefaultPatchBaseline(const Model::RegisterDefaultPatchBaselineRequest& request) const; /** * A Callable wrapper for RegisterDefaultPatchBaseline that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterDefaultPatchBaselineOutcomeCallable RegisterDefaultPatchBaselineCallable(const RegisterDefaultPatchBaselineRequestT& request) const { return SubmitCallable(&SSMClient::RegisterDefaultPatchBaseline, request); } /** * An Async wrapper for RegisterDefaultPatchBaseline that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterDefaultPatchBaselineAsync(const RegisterDefaultPatchBaselineRequestT& request, const RegisterDefaultPatchBaselineResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::RegisterDefaultPatchBaseline, request, handler, context); } /** *

Registers a patch baseline for a patch group.

See Also:

AWS * API Reference

*/ virtual Model::RegisterPatchBaselineForPatchGroupOutcome RegisterPatchBaselineForPatchGroup(const Model::RegisterPatchBaselineForPatchGroupRequest& request) const; /** * A Callable wrapper for RegisterPatchBaselineForPatchGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterPatchBaselineForPatchGroupOutcomeCallable RegisterPatchBaselineForPatchGroupCallable(const RegisterPatchBaselineForPatchGroupRequestT& request) const { return SubmitCallable(&SSMClient::RegisterPatchBaselineForPatchGroup, request); } /** * An Async wrapper for RegisterPatchBaselineForPatchGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterPatchBaselineForPatchGroupAsync(const RegisterPatchBaselineForPatchGroupRequestT& request, const RegisterPatchBaselineForPatchGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::RegisterPatchBaselineForPatchGroup, request, handler, context); } /** *

Registers a target with a maintenance window.

See Also:

AWS * API Reference

*/ virtual Model::RegisterTargetWithMaintenanceWindowOutcome RegisterTargetWithMaintenanceWindow(const Model::RegisterTargetWithMaintenanceWindowRequest& request) const; /** * A Callable wrapper for RegisterTargetWithMaintenanceWindow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterTargetWithMaintenanceWindowOutcomeCallable RegisterTargetWithMaintenanceWindowCallable(const RegisterTargetWithMaintenanceWindowRequestT& request) const { return SubmitCallable(&SSMClient::RegisterTargetWithMaintenanceWindow, request); } /** * An Async wrapper for RegisterTargetWithMaintenanceWindow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterTargetWithMaintenanceWindowAsync(const RegisterTargetWithMaintenanceWindowRequestT& request, const RegisterTargetWithMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::RegisterTargetWithMaintenanceWindow, request, handler, context); } /** *

Adds a new task to a maintenance window.

See Also:

AWS * API Reference

*/ virtual Model::RegisterTaskWithMaintenanceWindowOutcome RegisterTaskWithMaintenanceWindow(const Model::RegisterTaskWithMaintenanceWindowRequest& request) const; /** * A Callable wrapper for RegisterTaskWithMaintenanceWindow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterTaskWithMaintenanceWindowOutcomeCallable RegisterTaskWithMaintenanceWindowCallable(const RegisterTaskWithMaintenanceWindowRequestT& request) const { return SubmitCallable(&SSMClient::RegisterTaskWithMaintenanceWindow, request); } /** * An Async wrapper for RegisterTaskWithMaintenanceWindow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterTaskWithMaintenanceWindowAsync(const RegisterTaskWithMaintenanceWindowRequestT& request, const RegisterTaskWithMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::RegisterTaskWithMaintenanceWindow, request, handler, context); } /** *

Removes tag keys from the specified resource.

See Also:

AWS * API Reference

*/ virtual Model::RemoveTagsFromResourceOutcome RemoveTagsFromResource(const Model::RemoveTagsFromResourceRequest& request) const; /** * A Callable wrapper for RemoveTagsFromResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveTagsFromResourceOutcomeCallable RemoveTagsFromResourceCallable(const RemoveTagsFromResourceRequestT& request) const { return SubmitCallable(&SSMClient::RemoveTagsFromResource, request); } /** * An Async wrapper for RemoveTagsFromResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveTagsFromResourceAsync(const RemoveTagsFromResourceRequestT& request, const RemoveTagsFromResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::RemoveTagsFromResource, request, handler, context); } /** *

ServiceSetting is an account-level setting for an Amazon Web * Services service. This setting defines how a user interacts with or uses a * service or a feature of a service. For example, if an Amazon Web Services * service charges money to the account based on feature or service usage, then the * Amazon Web Services service team might create a default setting of "false". This * means the user can't use this feature unless they change the setting to "true" * and intentionally opt in for a paid feature.

Services map a * SettingId object to a setting value. Amazon Web Services services * teams define the default value for a SettingId. You can't create a * new SettingId, but you can overwrite the default value if you have * the ssm:UpdateServiceSetting permission for the setting. Use the * GetServiceSetting API operation to view the current value. Use the * UpdateServiceSetting API operation to change the default setting.

*

Reset the service setting for the account to the default value as provisioned * by the Amazon Web Services service team.

See Also:

AWS * API Reference

*/ virtual Model::ResetServiceSettingOutcome ResetServiceSetting(const Model::ResetServiceSettingRequest& request) const; /** * A Callable wrapper for ResetServiceSetting that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResetServiceSettingOutcomeCallable ResetServiceSettingCallable(const ResetServiceSettingRequestT& request) const { return SubmitCallable(&SSMClient::ResetServiceSetting, request); } /** * An Async wrapper for ResetServiceSetting that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResetServiceSettingAsync(const ResetServiceSettingRequestT& request, const ResetServiceSettingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ResetServiceSetting, request, handler, context); } /** *

Reconnects a session to a managed node after it has been disconnected. * Connections can be resumed for disconnected sessions, but not terminated * sessions.

This command is primarily for use by client machines to * automatically reconnect during intermittent network issues. It isn't intended * for any other use.

See Also:

AWS * API Reference

*/ virtual Model::ResumeSessionOutcome ResumeSession(const Model::ResumeSessionRequest& request) const; /** * A Callable wrapper for ResumeSession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResumeSessionOutcomeCallable ResumeSessionCallable(const ResumeSessionRequestT& request) const { return SubmitCallable(&SSMClient::ResumeSession, request); } /** * An Async wrapper for ResumeSession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResumeSessionAsync(const ResumeSessionRequestT& request, const ResumeSessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::ResumeSession, request, handler, context); } /** *

Sends a signal to an Automation execution to change the current behavior or * status of the execution.

See Also:

AWS * API Reference

*/ virtual Model::SendAutomationSignalOutcome SendAutomationSignal(const Model::SendAutomationSignalRequest& request) const; /** * A Callable wrapper for SendAutomationSignal that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendAutomationSignalOutcomeCallable SendAutomationSignalCallable(const SendAutomationSignalRequestT& request) const { return SubmitCallable(&SSMClient::SendAutomationSignal, request); } /** * An Async wrapper for SendAutomationSignal that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendAutomationSignalAsync(const SendAutomationSignalRequestT& request, const SendAutomationSignalResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::SendAutomationSignal, request, handler, context); } /** *

Runs commands on one or more managed nodes.

See Also:

AWS API * Reference

*/ virtual Model::SendCommandOutcome SendCommand(const Model::SendCommandRequest& request) const; /** * A Callable wrapper for SendCommand that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendCommandOutcomeCallable SendCommandCallable(const SendCommandRequestT& request) const { return SubmitCallable(&SSMClient::SendCommand, request); } /** * An Async wrapper for SendCommand that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendCommandAsync(const SendCommandRequestT& request, const SendCommandResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::SendCommand, request, handler, context); } /** *

Runs an association immediately and only one time. This operation can be * helpful when troubleshooting associations.

See Also:

AWS * API Reference

*/ virtual Model::StartAssociationsOnceOutcome StartAssociationsOnce(const Model::StartAssociationsOnceRequest& request) const; /** * A Callable wrapper for StartAssociationsOnce that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartAssociationsOnceOutcomeCallable StartAssociationsOnceCallable(const StartAssociationsOnceRequestT& request) const { return SubmitCallable(&SSMClient::StartAssociationsOnce, request); } /** * An Async wrapper for StartAssociationsOnce that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartAssociationsOnceAsync(const StartAssociationsOnceRequestT& request, const StartAssociationsOnceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::StartAssociationsOnce, request, handler, context); } /** *

Initiates execution of an Automation runbook.

See Also:

AWS * API Reference

*/ virtual Model::StartAutomationExecutionOutcome StartAutomationExecution(const Model::StartAutomationExecutionRequest& request) const; /** * A Callable wrapper for StartAutomationExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartAutomationExecutionOutcomeCallable StartAutomationExecutionCallable(const StartAutomationExecutionRequestT& request) const { return SubmitCallable(&SSMClient::StartAutomationExecution, request); } /** * An Async wrapper for StartAutomationExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartAutomationExecutionAsync(const StartAutomationExecutionRequestT& request, const StartAutomationExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::StartAutomationExecution, request, handler, context); } /** *

Creates a change request for Change Manager. The Automation runbooks * specified in the change request run only after all required approvals for the * change request have been received.

See Also:

AWS * API Reference

*/ virtual Model::StartChangeRequestExecutionOutcome StartChangeRequestExecution(const Model::StartChangeRequestExecutionRequest& request) const; /** * A Callable wrapper for StartChangeRequestExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartChangeRequestExecutionOutcomeCallable StartChangeRequestExecutionCallable(const StartChangeRequestExecutionRequestT& request) const { return SubmitCallable(&SSMClient::StartChangeRequestExecution, request); } /** * An Async wrapper for StartChangeRequestExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartChangeRequestExecutionAsync(const StartChangeRequestExecutionRequestT& request, const StartChangeRequestExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::StartChangeRequestExecution, request, handler, context); } /** *

Initiates a connection to a target (for example, a managed node) for a * Session Manager session. Returns a URL and token that can be used to open a * WebSocket connection for sending input and receiving outputs.

*

Amazon Web Services CLI usage: start-session is an interactive * command that requires the Session Manager plugin to be installed on the client * machine making the call. For information, see Install * the Session Manager plugin for the Amazon Web Services CLI in the Amazon * Web Services Systems Manager User Guide.

Amazon Web Services Tools * for PowerShell usage: Start-SSMSession isn't currently supported by Amazon Web * Services Tools for PowerShell on Windows local machines.

See * Also:

AWS * API Reference

*/ virtual Model::StartSessionOutcome StartSession(const Model::StartSessionRequest& request) const; /** * A Callable wrapper for StartSession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartSessionOutcomeCallable StartSessionCallable(const StartSessionRequestT& request) const { return SubmitCallable(&SSMClient::StartSession, request); } /** * An Async wrapper for StartSession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartSessionAsync(const StartSessionRequestT& request, const StartSessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::StartSession, request, handler, context); } /** *

Stop an Automation that is currently running.

See Also:

AWS * API Reference

*/ virtual Model::StopAutomationExecutionOutcome StopAutomationExecution(const Model::StopAutomationExecutionRequest& request) const; /** * A Callable wrapper for StopAutomationExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopAutomationExecutionOutcomeCallable StopAutomationExecutionCallable(const StopAutomationExecutionRequestT& request) const { return SubmitCallable(&SSMClient::StopAutomationExecution, request); } /** * An Async wrapper for StopAutomationExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopAutomationExecutionAsync(const StopAutomationExecutionRequestT& request, const StopAutomationExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::StopAutomationExecution, request, handler, context); } /** *

Permanently ends a session and closes the data connection between the Session * Manager client and SSM Agent on the managed node. A terminated session can't be * resumed.

See Also:

AWS * API Reference

*/ virtual Model::TerminateSessionOutcome TerminateSession(const Model::TerminateSessionRequest& request) const; /** * A Callable wrapper for TerminateSession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TerminateSessionOutcomeCallable TerminateSessionCallable(const TerminateSessionRequestT& request) const { return SubmitCallable(&SSMClient::TerminateSession, request); } /** * An Async wrapper for TerminateSession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TerminateSessionAsync(const TerminateSessionRequestT& request, const TerminateSessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::TerminateSession, request, handler, context); } /** *

Remove a label or labels from a parameter.

See Also:

AWS * API Reference

*/ virtual Model::UnlabelParameterVersionOutcome UnlabelParameterVersion(const Model::UnlabelParameterVersionRequest& request) const; /** * A Callable wrapper for UnlabelParameterVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UnlabelParameterVersionOutcomeCallable UnlabelParameterVersionCallable(const UnlabelParameterVersionRequestT& request) const { return SubmitCallable(&SSMClient::UnlabelParameterVersion, request); } /** * An Async wrapper for UnlabelParameterVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UnlabelParameterVersionAsync(const UnlabelParameterVersionRequestT& request, const UnlabelParameterVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::UnlabelParameterVersion, request, handler, context); } /** *

Updates an association. You can update the association name and version, the * document version, schedule, parameters, and Amazon Simple Storage Service * (Amazon S3) output. When you call UpdateAssociation, the system * removes all optional parameters from the request and overwrites the association * with null values for those parameters. This is by design. You must specify all * optional parameters in the call, even if you are not changing the parameters. * This includes the Name parameter. Before calling this API action, * we recommend that you call the DescribeAssociation API operation and make * a note of all optional parameters required for your * UpdateAssociation call.

In order to call this API operation, * a user, group, or role must be granted permission to call the * DescribeAssociation API operation. If you don't have permission to call * DescribeAssociation, then you receive the following error: An * error occurred (AccessDeniedException) when calling the UpdateAssociation * operation: User: <user_arn> isn't authorized to perform: * ssm:DescribeAssociation on resource: <resource_arn>

*

When you update an association, the association immediately runs * against the specified targets. You can add the * ApplyOnlyAtCronInterval parameter to run the association during the * next schedule run.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAssociationOutcome UpdateAssociation(const Model::UpdateAssociationRequest& request) const; /** * A Callable wrapper for UpdateAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAssociationOutcomeCallable UpdateAssociationCallable(const UpdateAssociationRequestT& request) const { return SubmitCallable(&SSMClient::UpdateAssociation, request); } /** * An Async wrapper for UpdateAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAssociationAsync(const UpdateAssociationRequestT& request, const UpdateAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::UpdateAssociation, request, handler, context); } /** *

Updates the status of the Amazon Web Services Systems Manager document (SSM * document) associated with the specified managed node.

* UpdateAssociationStatus is primarily used by the Amazon Web * Services Systems Manager Agent (SSM Agent) to report status updates about your * associations and is only used for associations created with the * InstanceId legacy parameter.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAssociationStatusOutcome UpdateAssociationStatus(const Model::UpdateAssociationStatusRequest& request) const; /** * A Callable wrapper for UpdateAssociationStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAssociationStatusOutcomeCallable UpdateAssociationStatusCallable(const UpdateAssociationStatusRequestT& request) const { return SubmitCallable(&SSMClient::UpdateAssociationStatus, request); } /** * An Async wrapper for UpdateAssociationStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAssociationStatusAsync(const UpdateAssociationStatusRequestT& request, const UpdateAssociationStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::UpdateAssociationStatus, request, handler, context); } /** *

Updates one or more values for an SSM document.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDocumentOutcome UpdateDocument(const Model::UpdateDocumentRequest& request) const; /** * A Callable wrapper for UpdateDocument that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDocumentOutcomeCallable UpdateDocumentCallable(const UpdateDocumentRequestT& request) const { return SubmitCallable(&SSMClient::UpdateDocument, request); } /** * An Async wrapper for UpdateDocument that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDocumentAsync(const UpdateDocumentRequestT& request, const UpdateDocumentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::UpdateDocument, request, handler, context); } /** *

Set the default version of a document.

If you change a * document version for a State Manager association, Systems Manager immediately * runs the association unless you previously specifed the * apply-only-at-cron-interval parameter.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateDocumentDefaultVersionOutcome UpdateDocumentDefaultVersion(const Model::UpdateDocumentDefaultVersionRequest& request) const; /** * A Callable wrapper for UpdateDocumentDefaultVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDocumentDefaultVersionOutcomeCallable UpdateDocumentDefaultVersionCallable(const UpdateDocumentDefaultVersionRequestT& request) const { return SubmitCallable(&SSMClient::UpdateDocumentDefaultVersion, request); } /** * An Async wrapper for UpdateDocumentDefaultVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDocumentDefaultVersionAsync(const UpdateDocumentDefaultVersionRequestT& request, const UpdateDocumentDefaultVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::UpdateDocumentDefaultVersion, request, handler, context); } /** *

Updates information related to approval reviews for a specific version of a * change template in Change Manager.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDocumentMetadataOutcome UpdateDocumentMetadata(const Model::UpdateDocumentMetadataRequest& request) const; /** * A Callable wrapper for UpdateDocumentMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDocumentMetadataOutcomeCallable UpdateDocumentMetadataCallable(const UpdateDocumentMetadataRequestT& request) const { return SubmitCallable(&SSMClient::UpdateDocumentMetadata, request); } /** * An Async wrapper for UpdateDocumentMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDocumentMetadataAsync(const UpdateDocumentMetadataRequestT& request, const UpdateDocumentMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::UpdateDocumentMetadata, request, handler, context); } /** *

Updates an existing maintenance window. Only specified parameters are * modified.

The value you specify for Duration * determines the specific end time for the maintenance window based on the time it * begins. No maintenance window tasks are permitted to start after the resulting * endtime minus the number of hours you specify for Cutoff. For * example, if the maintenance window starts at 3 PM, the duration is three hours, * and the value you specify for Cutoff is one hour, no maintenance * window tasks can start after 5 PM.

See Also:

AWS * API Reference

*/ virtual Model::UpdateMaintenanceWindowOutcome UpdateMaintenanceWindow(const Model::UpdateMaintenanceWindowRequest& request) const; /** * A Callable wrapper for UpdateMaintenanceWindow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateMaintenanceWindowOutcomeCallable UpdateMaintenanceWindowCallable(const UpdateMaintenanceWindowRequestT& request) const { return SubmitCallable(&SSMClient::UpdateMaintenanceWindow, request); } /** * An Async wrapper for UpdateMaintenanceWindow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateMaintenanceWindowAsync(const UpdateMaintenanceWindowRequestT& request, const UpdateMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::UpdateMaintenanceWindow, request, handler, context); } /** *

Modifies the target of an existing maintenance window. You can change the * following:

  • Name

  • Description

  • *

    Owner

  • IDs for an ID target

  • Tags for a Tag * target

  • From any supported tag type to another. The three * supported tag types are ID target, Tag target, and resource group. For more * information, see Target.

If a parameter is * null, then the corresponding field isn't modified.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateMaintenanceWindowTargetOutcome UpdateMaintenanceWindowTarget(const Model::UpdateMaintenanceWindowTargetRequest& request) const; /** * A Callable wrapper for UpdateMaintenanceWindowTarget that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateMaintenanceWindowTargetOutcomeCallable UpdateMaintenanceWindowTargetCallable(const UpdateMaintenanceWindowTargetRequestT& request) const { return SubmitCallable(&SSMClient::UpdateMaintenanceWindowTarget, request); } /** * An Async wrapper for UpdateMaintenanceWindowTarget that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateMaintenanceWindowTargetAsync(const UpdateMaintenanceWindowTargetRequestT& request, const UpdateMaintenanceWindowTargetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::UpdateMaintenanceWindowTarget, request, handler, context); } /** *

Modifies a task assigned to a maintenance window. You can't change the task * type, but you can change the following values:

  • * TaskARN. For example, you can change a RUN_COMMAND * task from AWS-RunPowerShellScript to * AWS-RunShellScript.

  • ServiceRoleArn *

  • TaskInvocationParameters

  • * Priority

  • MaxConcurrency

    • *

  • MaxErrors

One or more targets * must be specified for maintenance window Run Command-type tasks. Depending on * the task, targets are optional for other maintenance window task types * (Automation, Lambda, and Step Functions). For more information about running * tasks that don't specify targets, see Registering * maintenance window tasks without targets in the Amazon Web Services * Systems Manager User Guide.

If the value for a parameter in * UpdateMaintenanceWindowTask is null, then the corresponding field * isn't modified. If you set Replace to true, then all fields * required by the RegisterTaskWithMaintenanceWindow operation are required * for this request. Optional fields that aren't specified are set to null.

*

When you update a maintenance window task that has options * specified in TaskInvocationParameters, you must provide again all * the TaskInvocationParameters values that you want to retain. The * values you don't specify again are removed. For example, suppose that when you * registered a Run Command task, you specified * TaskInvocationParameters values for Comment, * NotificationConfig, and OutputS3BucketName. If you * update the maintenance window task and specify only a different * OutputS3BucketName value, the values for Comment and * NotificationConfig are removed.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateMaintenanceWindowTaskOutcome UpdateMaintenanceWindowTask(const Model::UpdateMaintenanceWindowTaskRequest& request) const; /** * A Callable wrapper for UpdateMaintenanceWindowTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateMaintenanceWindowTaskOutcomeCallable UpdateMaintenanceWindowTaskCallable(const UpdateMaintenanceWindowTaskRequestT& request) const { return SubmitCallable(&SSMClient::UpdateMaintenanceWindowTask, request); } /** * An Async wrapper for UpdateMaintenanceWindowTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateMaintenanceWindowTaskAsync(const UpdateMaintenanceWindowTaskRequestT& request, const UpdateMaintenanceWindowTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::UpdateMaintenanceWindowTask, request, handler, context); } /** *

Changes the Identity and Access Management (IAM) role that is assigned to the * on-premises server, edge device, or virtual machines (VM). IAM roles are first * assigned to these hybrid nodes during the activation process. For more * information, see CreateActivation.

See Also:

AWS * API Reference

*/ virtual Model::UpdateManagedInstanceRoleOutcome UpdateManagedInstanceRole(const Model::UpdateManagedInstanceRoleRequest& request) const; /** * A Callable wrapper for UpdateManagedInstanceRole that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateManagedInstanceRoleOutcomeCallable UpdateManagedInstanceRoleCallable(const UpdateManagedInstanceRoleRequestT& request) const { return SubmitCallable(&SSMClient::UpdateManagedInstanceRole, request); } /** * An Async wrapper for UpdateManagedInstanceRole that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateManagedInstanceRoleAsync(const UpdateManagedInstanceRoleRequestT& request, const UpdateManagedInstanceRoleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::UpdateManagedInstanceRole, request, handler, context); } /** *

Edit or change an OpsItem. You must have permission in Identity and Access * Management (IAM) to update an OpsItem. For more information, see Set * up OpsCenter in the Amazon Web Services Systems Manager User * Guide.

Operations engineers and IT professionals use Amazon Web * Services Systems Manager OpsCenter to view, investigate, and remediate * operational issues impacting the performance and health of their Amazon Web * Services resources. For more information, see OpsCenter * in the Amazon Web Services Systems Manager User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateOpsItemOutcome UpdateOpsItem(const Model::UpdateOpsItemRequest& request) const; /** * A Callable wrapper for UpdateOpsItem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateOpsItemOutcomeCallable UpdateOpsItemCallable(const UpdateOpsItemRequestT& request) const { return SubmitCallable(&SSMClient::UpdateOpsItem, request); } /** * An Async wrapper for UpdateOpsItem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateOpsItemAsync(const UpdateOpsItemRequestT& request, const UpdateOpsItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::UpdateOpsItem, request, handler, context); } /** *

Amazon Web Services Systems Manager calls this API operation when you edit * OpsMetadata in Application Manager.

See Also:

AWS * API Reference

*/ virtual Model::UpdateOpsMetadataOutcome UpdateOpsMetadata(const Model::UpdateOpsMetadataRequest& request) const; /** * A Callable wrapper for UpdateOpsMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateOpsMetadataOutcomeCallable UpdateOpsMetadataCallable(const UpdateOpsMetadataRequestT& request) const { return SubmitCallable(&SSMClient::UpdateOpsMetadata, request); } /** * An Async wrapper for UpdateOpsMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateOpsMetadataAsync(const UpdateOpsMetadataRequestT& request, const UpdateOpsMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::UpdateOpsMetadata, request, handler, context); } /** *

Modifies an existing patch baseline. Fields not specified in the request are * left unchanged.

For information about valid key-value pairs in * PatchFilters for each supported operating system type, see * PatchFilter.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePatchBaselineOutcome UpdatePatchBaseline(const Model::UpdatePatchBaselineRequest& request) const; /** * A Callable wrapper for UpdatePatchBaseline that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePatchBaselineOutcomeCallable UpdatePatchBaselineCallable(const UpdatePatchBaselineRequestT& request) const { return SubmitCallable(&SSMClient::UpdatePatchBaseline, request); } /** * An Async wrapper for UpdatePatchBaseline that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePatchBaselineAsync(const UpdatePatchBaselineRequestT& request, const UpdatePatchBaselineResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::UpdatePatchBaseline, request, handler, context); } /** *

Update a resource data sync. After you create a resource data sync for a * Region, you can't change the account options for that sync. For example, if you * create a sync in the us-east-2 (Ohio) Region and you choose the Include * only the current account option, you can't edit that sync later and * choose the Include all accounts from my Organizations configuration * option. Instead, you must delete the first resource data sync, and create a new * one.

This API operation only supports a resource data sync that * was created with a SyncFromSource SyncType.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateResourceDataSyncOutcome UpdateResourceDataSync(const Model::UpdateResourceDataSyncRequest& request) const; /** * A Callable wrapper for UpdateResourceDataSync that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateResourceDataSyncOutcomeCallable UpdateResourceDataSyncCallable(const UpdateResourceDataSyncRequestT& request) const { return SubmitCallable(&SSMClient::UpdateResourceDataSync, request); } /** * An Async wrapper for UpdateResourceDataSync that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateResourceDataSyncAsync(const UpdateResourceDataSyncRequestT& request, const UpdateResourceDataSyncResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::UpdateResourceDataSync, request, handler, context); } /** *

ServiceSetting is an account-level setting for an Amazon Web * Services service. This setting defines how a user interacts with or uses a * service or a feature of a service. For example, if an Amazon Web Services * service charges money to the account based on feature or service usage, then the * Amazon Web Services service team might create a default setting of "false". This * means the user can't use this feature unless they change the setting to "true" * and intentionally opt in for a paid feature.

Services map a * SettingId object to a setting value. Amazon Web Services services * teams define the default value for a SettingId. You can't create a * new SettingId, but you can overwrite the default value if you have * the ssm:UpdateServiceSetting permission for the setting. Use the * GetServiceSetting API operation to view the current value. Or, use the * ResetServiceSetting to change the value back to the original value * defined by the Amazon Web Services service team.

Update the service * setting for the account.

See Also:

AWS * API Reference

*/ virtual Model::UpdateServiceSettingOutcome UpdateServiceSetting(const Model::UpdateServiceSettingRequest& request) const; /** * A Callable wrapper for UpdateServiceSetting that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateServiceSettingOutcomeCallable UpdateServiceSettingCallable(const UpdateServiceSettingRequestT& request) const { return SubmitCallable(&SSMClient::UpdateServiceSetting, request); } /** * An Async wrapper for UpdateServiceSetting that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateServiceSettingAsync(const UpdateServiceSettingRequestT& request, const UpdateServiceSettingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SSMClient::UpdateServiceSetting, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const SSMClientConfiguration& clientConfiguration); SSMClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace SSM } // namespace Aws